Add LibraryLoader.resetAsync.

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 82 matching lines @@
 /// really need.
 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);
 
 Stopwatch wallClock = new Stopwatch();
 
+Compiler cachedCompiler;
+
 /// Iterator for reading lines from [io.stdin].
 class StdinIterator implements Iterator<String> {
   String current;
 
   bool moveNext() {
     current = io.stdin.readLineSync();
     return true;
   }
 }
 
@@ skipping 63 matching lines @@
     return prompt('Position: ').then((String position) {
       return parseUserInput(fileName, position, inputProvider, handler);
     });
   });
 }
 
 /// Create an input provider that implements the behavior documented at
 /// [simulateMutation].
 api.CompilerInputProvider simulateMutation(
     String fileName,
-    SourceFileProvider inputProvider) {
+    api.CompilerInputProvider 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';
     printVerbose('fake inputProvider#$counter($uri): $poiCount $count');
     if (uri == script) {
       if (poiCount == count) {
@@ skipping 62 matching lines @@
       wallClock.reset();
       return parseUserInput(fileName, positionString, inputProvider, handler);
     });
   }
 
   printWallClock("\n\n\nparseUserInput('$fileName', '$positionString')");
 
   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.'));
+      positionString, onError: (_) { print('Please enter an integer.'); });
   if (position == null) return repeat();
 
   inputProvider(script);
   if (isVerbose) {
     handler(
         script, position, position + 1,
         'Point of interest. '
         'Cursor is immediately before highlighted character.',
         api.Diagnostic.HINT);
   }
@@ skipping 39 matching lines @@
         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
 /// works for instances of [PartialElement] or [LibraryElement].  Support for
 /// [LibraryElement] is currently limited, and works only for named libraries.
-Token findToken(Element element, int position) {
+Token findToken(modelx.ElementX element, int position) {
   Token beginToken;
   if (element is PartialElement) {
-    beginToken = element.beginToken;
+    beginToken = (element as PartialElement).beginToken;
   } else if (element is PartialClassElement) {
     beginToken = element.beginToken;
   } else if (element.isLibrary) {
     // TODO(ahe): Generalize support for library elements (and update above
     // documentation).
-    LibraryElement lib = element;
+    modelx.LibraryElementX lib = element;
     var tag = lib.libraryTag;
     if (tag != null) {
       beginToken = tag.libraryKeyword;
     }
   } else {
     beginToken = element.position;
   }
   if (beginToken == null) return null;
   for (Token token = beginToken; token.kind != EOF_TOKEN; token = token.next) {
     if (token.charOffset < position && position <= token.next.charOffset) {
       return token;
     }
   }
   return null;
 }
 
-Compiler cachedCompiler;
-
 Future<Element> runPoi(
-    Uri script, int position,
+    Uri script,
+    int position,
     api.CompilerInputProvider inputProvider,
     api.DiagnosticHandler handler) {
-
   Uri libraryRoot = Uri.base.resolve('sdk/');
   Uri packageRoot = Uri.base.resolveUri(
       new Uri.file('${Platform.packageRoot}/'));
 
   var options = [
       '--analyze-main',
       '--analyze-only',
       '--no-source-maps',
       '--verbose',
       '--categories=Client,Server',
       '--incremental-support',
       '--disable-type-inference',
   ];
 
-  cachedCompiler = reuseCompiler(
+  return reuseCompiler(
       diagnosticHandler: handler,
       inputProvider: inputProvider,
       options: options,
       cachedCompiler: cachedCompiler,
       libraryRoot: libraryRoot,
       packageRoot: packageRoot,
-      packagesAreImmutable: true);
+      packagesAreImmutable: true).then((Compiler newCompiler) {
+    var filter = new ScriptOnlyFilter(script);
+    newCompiler.enqueuerFilter = filter;
+    return runPoiInternal(newCompiler, script, position);
+  });
+}
 
-  cachedCompiler.enqueuerFilter = new ScriptOnlyFilter(script);
+Future<Element> runPoiInternal(
+    Compiler newCompiler,
+    Uri uri,
+    int position) {
+  cachedCompiler = newCompiler;
 
-  return cachedCompiler.run(script).then((success) {
+  return cachedCompiler.run(uri).then((success) {
     if (success != true) {
       throw 'Compilation failed';
     }
     return findPosition(position, cachedCompiler.mainApp);
   });
 }
 
 Element findPosition(int position, Element element) {
   FindPositionVisitor visitor = new FindPositionVisitor(position, element);
   element.accept(visitor);
   return visitor.element;
 }
 
 String scopeInformation(Element element, int position) {
   ScopeInformationVisitor visitor =
       new ScopeInformationVisitor(element, position);
   element.accept(visitor);
   return '${visitor.buffer}';
 }
 
 class FindPositionVisitor extends ElementVisitor {
   final int position;
   Element element;
 
   FindPositionVisitor(this.position, this.element);
 
   visitElement(Element e) {
     if (e is PartialElement) {
-      if (e.beginToken.charOffset <= position &&
-          position < e.endToken.next.charOffset) {
+      if ((e as PartialElement).beginToken.charOffset <= position &&
+          position < (e as PartialElement).endToken.next.charOffset) {
         element = e;
       }
     }
   }
 
   visitClassElement(ClassElement e) {
     if (e is PartialClassElement) {
       if (e.beginToken.charOffset <= position &&
           position < e.endToken.next.charOffset) {
         element = e;
@@ skipping 269 matching lines @@
     buffer.write('\n');
     indented.write('}');
   }
 }
 
 modelx.ScopeX localScope(modelx.LibraryElementX element) => element.localScope;
 
 modelx.ImportScope importScope(modelx.LibraryElementX element) {
   return element.importScope;
 }