Add verbose option to poi.dart.

dart/site/try/poi/poi.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library trydart.poi;
 
 import 'dart:async' show
     Completer,
     Future,
     Stream;
@@ skipping 70 matching lines @@
 /// information about position 11, then position 22 in test.dart.1.dart, then
 /// position 33 in test.dart.2.dart, and finally position 44 in
 /// test.dart.3.dart.
 bool isSimulateMutationEnabled = false;
 
 /// Counts the number of times [runPoi] has been invoked.
 int poiCount;
 
 int globalCounter = 0;
 
+/// Enabled by the option --verbose (or -v). Prints more information than you
+/// really need.

[Johnni Winther, 2014/09/09 13:49:13]

Nice comment :)

[ahe, 2014/09/09 14:35:13]

Acknowledged.

+bool isVerbose = false;
+
+/// When true (the default value) print serialized scope information at the
+/// provided position.
+const bool PRINT_SCOPE_INFO =
+    const bool.fromEnvironment('PRINT_SCOPE_INFO', defaultValue: true);
+
 /// Iterator for reading lines from [io.stdin].
 class StdinIterator implements Iterator<String> {
   String current;
 
   bool moveNext() {
     current = io.stdin.readLineSync();
     return true;
   }
 }
 
+printVerbose(message) {
+  if (!isVerbose) return;
+  print(message);
+}
+
 main(List<String> arguments) {
   poiCount = 0;
   List<String> nonOptionArguments = [];
   for (String argument in arguments) {
     if (argument.startsWith('-')) {
       switch (argument) {
         case '--simulate-mutation':
           isSimulateMutationEnabled = true;
           break;
+        case '-v':
+        case '--verbose':
+          isVerbose = true;
+          break;
         default:
           throw 'Unknown option: $argument.';
       }
     } else {
       nonOptionArguments.add(argument);
     }
   }
   if (nonOptionArguments.isEmpty) {
     stdin = new StdinIterator();
   } else {
@@ skipping 21 matching lines @@
 api.CompilerInputProvider simulateMutation(
     String fileName,
     SourceFileProvider inputProvider) {
   Uri script = Uri.base.resolveUri(new Uri.file(fileName));
   int count = poiCount;
   Future cache;
   String cachedFileName = script.toFilePath();
   int counter = ++globalCounter;
   return (Uri uri) {
     if (counter != globalCounter) throw 'Using old provider';
-    print('fake inputProvider#$counter($uri): $poiCount $count');
+    printVerbose('fake inputProvider#$counter($uri): $poiCount $count');
     if (uri == script) {
       if (poiCount == count) {
         cachedFileName = uri.toFilePath();
         if (count != 0) {
           cachedFileName = '$cachedFileName.$count.dart';
         }
-        print('Not using cached version of $cachedFileName');
+        printVerbose('Not using cached version of $cachedFileName');
         cache = new File(cachedFileName).readAsBytes().then((data) {
-          print('Read file $cachedFileName: ${UTF8.decode(data)}');
+          printVerbose('Read file $cachedFileName: ${UTF8.decode(data)}');
           return data;
         });
         count++;
       } else {
-        print('Using cached version of $cachedFileName');
+        printVerbose('Using cached version of $cachedFileName');
       }
       return cache;
     } else {
-      print('Using realProvider for $uri');
+      printVerbose('Using original provider for $uri');
       return inputProvider(uri);
     }
   };
 }
 
 Future<String> prompt(message) {
   if (stdin is StdinIterator) {
     stdout.write(message);
   }
   return stdout.flush().then((_) {
@@ skipping 35 matching lines @@
     });
   }
 
   Uri script = Uri.base.resolveUri(new Uri.file(fileName));
   if (positionString == null) return null;
   int position = int.parse(
       positionString, onError: (_) => print('Please enter an integer.'));
   if (position == null) return repeat();
 
   inputProvider(script);
-  handler(
-      script, position, position + 1,
-      'Point of interest. Cursor is immediately before highlighted character.',
-      api.Diagnostic.HINT);
+  if (isVerbose) {
+    handler(
+        script, position, position + 1,
+        'Point of interest. '
+        'Cursor is immediately before highlighted character.',
+        api.Diagnostic.HINT);
+  }
 
   Stopwatch sw = new Stopwatch()..start();
 
   Future future = runPoi(script, position, inputProvider, handler);
   return future.then((Element element) {
     poiCount++;
     print('Resolving took ${sw.elapsedMicroseconds}us.');
     sw.reset();
     String info = scopeInformation(element, position);
     sw.stop();
-    print(info);
-    print('Scope information took ${sw.elapsedMicroseconds}us.');
+    if (PRINT_SCOPE_INFO) {
+      print(info);
+    }
+    printVerbose('Scope information took ${sw.elapsedMicroseconds}us.');
     sw..reset()..start();
     Token token = findToken(element, position);
     String prefix;
     if (token != null) {
       if (token.charOffset + token.charCount <= position) {
         // After the token; in whitespace, or in the beginning of another token.
         prefix = "";
       } else if (token.kind == IDENTIFIER_TOKEN ||
                  token.kind == KEYWORD_TOKEN) {
         prefix = token.value.substring(0, position - token.charOffset);
       }
     }
-    print('Find token took ${sw.elapsedMicroseconds}us.');
+    printVerbose('Find token took ${sw.elapsedMicroseconds}us.');
     sw.reset();
     if (prefix != null) {
       return queryDartMind(prefix, info).then((String dartMindSuggestion) {
         sw.stop();
         print('Dart Mind ($prefix): $dartMindSuggestion.');
-        print('Dart Mind took ${sw.elapsedMicroseconds}us.');
+        printVerbose('Dart Mind took ${sw.elapsedMicroseconds}us.');
         return repeat();
       });
     } else {
       print("Didn't talk to Dart Mind, no identifier at POI ($token).");
       return repeat();
     }
   });
 }
 
 /// Find the token corresponding to [position] in [element].  The method only
@@ skipping 367 matching lines @@
     buffer.write('\n');
     indented.write('}');
   }
 }
 
 modelx.ScopeX localScope(modelx.LibraryElementX element) => element.localScope;
 
 modelx.ImportScope importScope(modelx.LibraryElementX element) {
   return element.importScope;
 }