First pass at asynchronous input loading in dart2js.

sdk/lib/_internal/compiler/implementation/compiler.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 63 matching lines @@
 
 typedef void PostProcessAction();
 
 class PostProcessTask {
   final Element element;
   final PostProcessAction action;
 
   PostProcessTask(this.element, this.action);
 }
 
+// TODO(rnystrom): Now that file reading is asynchronous, this task is no longer
+// used and the time spent reading files isn't easily measurable (or even that
+// well-defined). As Peter says:
+//
+// As far as I can tell, we can only count how much time is being spent reading
+// files by having a global counter that covers the time from the beginning of
+// the compiler until it reaches a point when all libraries are scanned, and
+// subtract the time spent in other tasks.
+//
+// I think you should drop measureAsync. I think we can measure the time spent
+// reading files in dart2js.dart (you can just add a TODO).
 class ReadingFilesTask extends CompilerTask {
   ReadingFilesTask(Compiler compiler) : super(compiler);
   String get name => 'Reading input files';
 }
 
 abstract class Backend {
   final Compiler compiler;
   final ConstantSystem constantSystem;
 
   Backend(this.compiler,
@@ skipping 299 matching lines @@
   ClassElement jsInvocationMirrorClass;
   /// Document class from dart:mirrors.
   ClassElement documentClass;
   Element assertMethod;
   Element identicalFunction;
   Element functionApplyMethod;
   Element invokeOnMethod;
   Element createInvocationMirrorElement;
 
   Element get currentElement => _currentElement;
+  
+  void _setCurrentElement(Element newElement, Element oldElement) {
+    assert(invariant(
+        newElement == null ? CURRENT_ELEMENT_SPANNABLE : newElement, 
+        _currentElement == oldElement, 
+        message: "Current element mismatch. "
+          "Expected $oldElement but found $_currentElement."));
+    _currentElement = newElement;
+  }
 
   /**
    * Perform an operation, [f], returning the return value from [f].  If an
    * error occurs then report it as having occurred during compilation of
    * [element].  Can be nested.
    */
   withCurrentElement(Element element, f()) {
     Element old = currentElement;
-    _currentElement = element;
+    _setCurrentElement(element, old);
     try {
-      return f();
+      var result = f();
+      assert(invariant(element, result is! Future, 
+             message: '"withCurrentElement" called with asynchronous function. '
+                      'Use "withCurrentElementAsync" instead.'));
+      return result;
     } on SpannableAssertionFailure catch (ex) {
-      if (!hasCrashed) {
-        SourceSpan span = spanFromSpannable(ex.node);
-        reportError(ex.node, MessageKind.GENERIC, {'text': ex.message});
-        pleaseReportCrash();
-      }
-      hasCrashed = true;
+      onSpannableAssertionFailure(ex);
       rethrow;
     } on CompilerCancelledException catch (ex) {
       rethrow;
     } on StackOverflowError catch (ex) {
       // We cannot report anything useful in this case, because we
       // do not have enough stack space.
       rethrow;
     } catch (ex) {
-      try {
-        unhandledExceptionOnElement(element);
-      } catch (doubleFault) {
-        // Ignoring exceptions in exception handling.
-      }
+      onUnhandledException(element);
       rethrow;
     } finally {
-      _currentElement = old;
+      _setCurrentElement(old, element);
+    }
+  }
+  
+  Future withCurrentElementAsync(Element element, Future f()) {
+    Element old = currentElement;
+    _setCurrentElement(element, old);
+    try {
+      return f().catchError((ex) {

[ahe, 2013/08/02 11:50:19]

I don't think this will work. I'l talk to you in person.

[Johnni Winther, 2013/08/02 13:47:47]

Removed.

+        if (ex is SpannableAssertionFailure) {
+          onSpannableAssertionFailure(ex);
+        } else if (ex is CompilerCancelledException || 
+                   ex is StackOverflowError) {
+          // Do nothing.

[ahe, 2013/08/02 11:50:19]

Why is that?

+        } else {
+          onUnhandledException(element);
+        }
+        return new Future.error(ex);
+      })
+      .whenComplete(() {
+        _setCurrentElement(old, element);
+      });
+    } catch (ex) {
+      _setCurrentElement(old, element);
+      return new Future.error(ex); 
+    }
+  }
+  
+  void onSpannableAssertionFailure(SpannableAssertionFailure ex) {
+    if (!hasCrashed) {
+      SourceSpan span = spanFromSpannable(ex.node);
+      reportError(ex.node, MessageKind.GENERIC, {'text': ex.message});
+      pleaseReportCrash();
+    }
+    hasCrashed = true;
+  }
+  
+  void onUnhandledException(Element element) {
+    try {
+      unhandledExceptionOnElement(element);
+    } catch (doubleFault) {
+      // Ignoring exceptions in exception handling.
     }
   }
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   PatchParserTask patchParser;
   LibraryLoader libraryLoader;
   TreeValidatorTask validator;
@@ skipping 214 matching lines @@
       return spanFromTokens(annotation.beginToken, annotation.endToken);
     } else {
       throw 'No error location.';
     }
   }
 
   void log(message) {
     reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
-  bool run(Uri uri) {
+  Future<bool> run(Uri uri) {
     totalCompileTime.start();
-    try {
-      runCompiler(uri);
-    } on CompilerCancelledException catch (exception) {
-      log('Error: $exception');
-      return false;
-    } catch (exception) {
+
+    return runCompiler(uri).then((_) {
+      return true;
+    }).catchError((error) {
+      if (error is CompilerCancelledException) {
+        log('Error: $error');
+        return false;
+      }
+
       try {
         if (!hasCrashed) {
           hasCrashed = true;
           reportDiagnostic(new SourceSpan(uri, 0, 0),
                            MessageKind.COMPILER_CRASHED.error().toString(),
                            api.Diagnostic.CRASH);
           pleaseReportCrash();
         }
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
-      rethrow;
-    } finally {
+      throw error;
+    }).whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
-    }
-    return !compilationFailed;
+    }).then((_) {
+      return !compilationFailed;
+    });
   }
 
   bool hasIsolateSupport() => isolateLibrary != null;
 
   /**
    * This method is called before [library] import and export scopes have been
    * set up.
    */
   void onLibraryScanned(LibraryElement library, Uri uri) {
     if (dynamicClass != null) {
@@ skipping 36 matching lines @@
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember(const SourceString('getName'));
     } else if (symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
       symbolValidatedConstructor = symbolImplementationClass.lookupConstructor(
           symbolValidatedConstructorSelector);
     }
   }
 
-  LibraryElement scanBuiltinLibrary(String filename);
+  Future<LibraryElement> scanBuiltinLibrary(String filename);
 
   void initializeSpecialClasses() {
     final List missingCoreClasses = [];
     ClassElement lookupCoreClass(String name) {
       ClassElement result = coreLibrary.find(new SourceString(name));
       if (result == null) {
         missingCoreClasses.add(name);
       }
       return result;
     }
@@ skipping 55 matching lines @@
 
   Element _filledListConstructor;
   Element get filledListConstructor {
     if (_filledListConstructor != null) return _filledListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         const SourceString("filled"), listClass.getLibrary());
     return _filledListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
 
-  void scanBuiltinLibraries() {
-    jsHelperLibrary = scanBuiltinLibrary('_js_helper');
-    interceptorsLibrary = scanBuiltinLibrary('_interceptors');
-    foreignLibrary = scanBuiltinLibrary('_foreign_helper');
-    isolateHelperLibrary = scanBuiltinLibrary('_isolate_helper');
+  Future scanBuiltinLibraries() {
+    return scanBuiltinLibrary('_js_helper').then((LibraryElement library) {
+      jsHelperLibrary = library;
+      return scanBuiltinLibrary('_interceptors');
+    }).then((LibraryElement library) {
+      interceptorsLibrary = library;
+      return scanBuiltinLibrary('_foreign_helper');
+    }).then((LibraryElement library) {
+      foreignLibrary = library;
+      return scanBuiltinLibrary('_isolate_helper');
+    }).then((LibraryElement library) {
+      isolateHelperLibrary = library;
 
-    assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
-    identicalFunction = coreLibrary.find(const SourceString('identical'));
+      assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
+      identicalFunction = coreLibrary.find(const SourceString('identical'));
 
-    initializeSpecialClasses();
+      initializeSpecialClasses();
 
-    functionClass.ensureResolved(this);
-    functionApplyMethod =
-        functionClass.lookupLocalMember(const SourceString('apply'));
-    jsInvocationMirrorClass.ensureResolved(this);
-    invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
+      functionClass.ensureResolved(this);
+      functionApplyMethod =
+          functionClass.lookupLocalMember(const SourceString('apply'));
+      jsInvocationMirrorClass.ensureResolved(this);
+      invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
 
-    if (preserveComments) {
-      var uri = new Uri(scheme: 'dart', path: 'mirrors');
-      LibraryElement libraryElement =
-          libraryLoader.loadLibrary(uri, null, uri);
-      documentClass = libraryElement.find(const SourceString('Comment'));
-    }
+      if (preserveComments) {
+        var uri = new Uri(scheme: 'dart', path: 'mirrors');
+        return libraryLoader.loadLibrary(uri, null, uri).then(
+            (LibraryElement libraryElement) {
+          documentClass = libraryElement.find(const SourceString('Comment'));
+        });
+      }
+    });
   }
 
   void importHelperLibrary(LibraryElement library) {
     if (jsHelperLibrary != null) {
       libraryLoader.importLibrary(library, jsHelperLibrary, null);
     }
   }
 
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   Uri resolvePatchUri(String dartLibraryPath);
 
-  void runCompiler(Uri uri) {
+  Future runCompiler(Uri uri) {
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times.  Implement a better mechanism where StringWrapper
     // instances are shared on a per library basis.
     SourceString.canonicalizedValues.clear();
 
     assert(uri != null || analyzeOnly);
-    scanBuiltinLibraries();
-    if (librariesToAnalyzeWhenRun != null) {
-      for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-        log('analyzing $libraryUri ($buildId)');
-        libraryLoader.loadLibrary(libraryUri, null, libraryUri);
-      }
-    }
-    if (uri != null) {
-      if (analyzeOnly) {
-        log('analyzing $uri ($buildId)');
-      } else {
-        log('compiling $uri ($buildId)');
-      }
-      mainApp = libraryLoader.loadLibrary(uri, null, uri);
-    }
-    Element main = null;
-    if (mainApp != null) {
-      main = mainApp.find(MAIN);
-      if (main == null) {
-        if (!analyzeOnly) {
-          // Allow analyze only of libraries with no main.
-          reportFatalError(
-              mainApp,
-              MessageKind.GENERIC,
-              {'text': 'Error: Could not find "${MAIN.slowToString()}".'});
-        } else if (!analyzeAll) {
-          reportFatalError(
-              mainApp,
-              MessageKind.GENERIC,
-              {'text': 'Error: Could not find "${MAIN.slowToString()}". '
-                  'No source will be analyzed. '
-                  'Use "--analyze-all" to analyze all code in the library.'});
-        }
-      } else {
-        if (!main.isFunction()) {
-          reportFatalError(
-              main,
-              MessageKind.GENERIC,
-              {'text': 'Error: "${MAIN.slowToString()}" is not a function.'});
-        }
-        FunctionElement mainMethod = main;
-        FunctionSignature parameters = mainMethod.computeSignature(this);
-        parameters.forEachParameter((Element parameter) {
-          reportError(
-              parameter,
-              MessageKind.GENERIC,
-              {'text':
-                  'Error: "${MAIN.slowToString()}" cannot have parameters.'});
+    return scanBuiltinLibraries().then((_) {
+      if (librariesToAnalyzeWhenRun != null) {
+        return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
+          log('analyzing $libraryUri ($buildId)');
+          return libraryLoader.loadLibrary(libraryUri, null, libraryUri);
         });
       }
+    }).then((_) {
+      if (uri != null) {
+        if (analyzeOnly) {
+          log('analyzing $uri ($buildId)');
+        } else {
+          log('compiling $uri ($buildId)');
+        }
+        return libraryLoader.loadLibrary(uri, null, uri)
+            .then((LibraryElement library) {
+          mainApp = library;
+        });
+      }
+    }).then((_) {
+      Element main = null;
+      if (mainApp != null) {
+        main = mainApp.find(MAIN);
+        if (main == null) {
+          if (!analyzeOnly) {
+            // Allow analyze only of libraries with no main.
+            reportFatalError(
+                mainApp,
+                MessageKind.GENERIC,
+                {'text': 'Error: Could not find "${MAIN.slowToString()}".'});
+          } else if (!analyzeAll) {
+            reportFatalError(
+                mainApp,
+                MessageKind.GENERIC,
+                {'text': 'Error: Could not find "${MAIN.slowToString()}". '
+                    'No source will be analyzed. '
+                    'Use "--analyze-all" to analyze all code in the library.'});
+          }
+        } else {
+          if (!main.isFunction()) {
+            reportFatalError(
+                main,
+                MessageKind.GENERIC,
+                {'text': 'Error: "${MAIN.slowToString()}" is not a function.'});
+          }
+          FunctionElement mainMethod = main;
+          FunctionSignature parameters = mainMethod.computeSignature(this);
+          parameters.forEachParameter((Element parameter) {
+            reportError(
+                parameter,
+                MessageKind.GENERIC,
+                {'text':
+                    'Error: "${MAIN.slowToString()}" cannot have parameters.'});
+          });
+        }
 
-      mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+        mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
-      // In order to see if a library is deferred, we must compute the
-      // compile-time constants that are metadata.  This means adding
-      // something to the resolution queue.  So we cannot wait with
-      // this until after the resolution queue is processed.
-      // TODO(ahe): Clean this up, for example, by not enqueueing
-      // classes only used for metadata.
-      deferredLoadTask.findDeferredLibraries(mainApp);
-    }
+        // In order to see if a library is deferred, we must compute the
+        // compile-time constants that are metadata.  This means adding
+        // something to the resolution queue.  So we cannot wait with
+        // this until after the resolution queue is processed.
+        // TODO(ahe): Clean this up, for example, by not enqueueing
+        // classes only used for metadata.
+        deferredLoadTask.findDeferredLibraries(mainApp);
+      }
 
-    log('Resolving...');
-    phase = PHASE_RESOLVING;
-    if (analyzeAll) {
-      libraries.forEach(
-          (_, lib) => fullyEnqueueLibrary(lib, enqueuer.resolution));
-    }
-    // Elements required by enqueueHelpers are global dependencies
-    // that are not pulled in by a particular element.
-    backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
-    processQueue(enqueuer.resolution, main);
-    enqueuer.resolution.logSummary(log);
+      log('Resolving...');
+      phase = PHASE_RESOLVING;
+      if (analyzeAll) {
+        libraries.forEach(
+            (_, lib) => fullyEnqueueLibrary(lib, enqueuer.resolution));
+      }
+      // Elements required by enqueueHelpers are global dependencies
+      // that are not pulled in by a particular element.
+      backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
+      processQueue(enqueuer.resolution, main);
+      enqueuer.resolution.logSummary(log);
 
-    if (compilationFailed) return;
-    if (analyzeOnly) return;
-    assert(main != null);
-    phase = PHASE_DONE_RESOLVING;
+      if (compilationFailed) return;
+      if (analyzeOnly) return;
+      assert(main != null);
+      phase = PHASE_DONE_RESOLVING;
 
-    // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
-    // should know this.
-    world.populate();
-    // Compute whole-program-knowledge that the backend needs. (This might
-    // require the information computed in [world.populate].)
-    backend.onResolutionComplete();
+      // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
+      // should know this.
+      world.populate();
+      // Compute whole-program-knowledge that the backend needs. (This might
+      // require the information computed in [world.populate].)
+      backend.onResolutionComplete();
 
-    deferredLoadTask.onResolutionComplete(main);
+      deferredLoadTask.onResolutionComplete(main);
 
-    log('Inferring types...');
-    typesTask.onResolutionComplete(main);
+      log('Inferring types...');
+      typesTask.onResolutionComplete(main);
 
-    log('Compiling...');
-    phase = PHASE_COMPILING;
-    // TODO(johnniwinther): Move these to [CodegenEnqueuer].
-    if (hasIsolateSupport()) {
-      enqueuer.codegen.addToWorkList(
-          isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
-      enqueuer.codegen.registerGetOfStaticFunction(mainApp.find(MAIN));
-    }
-    if (enabledNoSuchMethod) {
-      enqueuer.codegen.registerInvocation(noSuchMethodSelector);
-      enqueuer.codegen.addToWorkList(createInvocationMirrorElement);
-    }
-    if (compileAll) {
-      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib, enqueuer.codegen));
-    }
-    processQueue(enqueuer.codegen, main);
-    enqueuer.codegen.logSummary(log);
+      log('Compiling...');
+      phase = PHASE_COMPILING;
+      // TODO(johnniwinther): Move these to [CodegenEnqueuer].
+      if (hasIsolateSupport()) {
+        enqueuer.codegen.addToWorkList(
+            isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
+        enqueuer.codegen.registerGetOfStaticFunction(mainApp.find(MAIN));
+      }
+      if (enabledNoSuchMethod) {
+        enqueuer.codegen.registerInvocation(noSuchMethodSelector);
+        enqueuer.codegen.addToWorkList(createInvocationMirrorElement);
+      }
+      if (compileAll) {
+        libraries.forEach((_, lib) => fullyEnqueueLibrary(lib,
+            enqueuer.codegen));
+      }
+      processQueue(enqueuer.codegen, main);
+      enqueuer.codegen.logSummary(log);
 
-    if (compilationFailed) return;
+      if (compilationFailed) return;
 
-    backend.assembleProgram();
+      backend.assembleProgram();
 
-    checkQueues();
+      checkQueues();
 
-    if (compilationFailed) {
-      assembledCode = null; // Signals failure.
-    }
+      if (compilationFailed) {
+        assembledCode = null; // Signals failure.
+      }
+    });
   }
 
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
@@ skipping 311 matching lines @@
   Uri translateResolvedUri(LibraryElement importingLibrary,
                            Uri resolvedUri, Node node) {
     unimplemented('Compiler.translateResolvedUri');
   }
 
   /**
    * Reads the script specified by the [readableUri].
    *
    * See [LibraryLoader] for terminology on URIs.
    */
-  Script readScript(Uri readableUri, [Node node]) {
+  Future<Script> readScript(Uri readableUri, [Node node]) {
     unimplemented('Compiler.readScript');
   }
 
   String get legDirectory {
     unimplemented('Compiler.legDirectory');
   }
 
   // TODO(karlklose): split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
   Element findHelper(SourceString name)
@@ skipping 123 matching lines @@
  * [invariant] as the argument to an [:assert:] statement:
  *
  *     assert(invariant(position, isValid));
  *
  * [spannable] must be non-null and will be used to provide positional
  * information in the generated error message.
  */
 bool invariant(Spannable spannable, var condition, {var message: null}) {
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
+  if (spannable == null) {
+    throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE, 
+        "Spannable was null for invariant. Use CURRENT_ELEMENT_SPANNABLE.");
+  }
   if (condition is Function){
     condition = condition();
   }
-  if (spannable == null || !condition) {
+  if (!condition) {
     if (message is Function) {
       message = message();
     }
     throw new SpannableAssertionFailure(spannable, message);
   }
   return true;
 }
 
 /// A sink that drains into /dev/null.
 class NullSink implements EventSink<String> {
   final String name;
 
   NullSink(this.name);
 
   add(String value) {}
 
   void addError(Object error) {}
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }