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 18 matching lines @@
    *
    * Invariant: [element] must be a declaration element.
    */
   final Element element;
   TreeElements resolutionTree;
 
   WorkItem(this.element, this.compilationContext) {
     assert(invariant(element, element.isDeclaration));
   }
 
-
   void run(Compiler compiler, Enqueuer world);
 }
 
 /// [WorkItem] used exclusively by the [ResolutionEnqueuer].
 class ResolutionWorkItem extends WorkItem {
   ResolutionWorkItem(Element element,
                      ItemCompilationContext compilationContext)
       : super(element, compilationContext);
 
   void run(Compiler compiler, ResolutionEnqueuer world) {
@@ skipping 24 matching lines @@
 
 typedef void PostProcessAction();
 
 class PostProcessTask {
   final Element element;
   final PostProcessAction action;
 
   PostProcessTask(this.element, this.action);
 }
 
-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,
           [ConstantSystem constantSystem = DART_CONSTANT_SYSTEM])
       : this.constantSystem = constantSystem;
 
   void initializeHelperClasses() {}
 
@@ skipping 139 matching lines @@
   ClassElement defaultSuperclass(ClassElement element) => compiler.objectClass;
 
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
     ClassElement classElement = element.getEnclosingClass();
     return classElement == compiler.objectClass;
   }
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
-  void onLibraryLoaded(LibraryElement library, Uri uri) {}
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
+    return new Future.value();
+  }
 
   void registerMetadataInstantiatedType(DartType type, TreeElements elements) {}
   void registerMetadataStaticUse(Element element) {}
   void registerMetadataGetOfStaticFunction(FunctionElement element) {}
 
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
@@ skipping 235 matching lines @@
   LibraryLoader libraryLoader;
   TreeValidatorTask validator;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
   ConstantHandler constantHandler;
   ConstantHandler metadataHandler;
   EnqueueTask enqueuer;
-  CompilerTask fileReadingTask;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   ContainerTracer containerTracer;
   String buildId;
 
   static const SourceString MAIN = const SourceString('main');
   static const SourceString CALL_OPERATOR_NAME = const SourceString('call');
   static const SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
   static const SourceString CREATE_INVOCATION_MIRROR =
@@ skipping 81 matching lines @@
       backend = jsBackend;
     } else {
       closureNamer = new closureMapping.ClosureNamer();
       backend = new dart_backend.DartBackend(this, strips);
     }
 
     // No-op in production mode.
     validator = new TreeValidatorTask(this);
 
     tasks = [
-      fileReadingTask = new ReadingFilesTask(this),
       libraryLoader = new LibraryLoaderTask(this),
       scanner = new ScannerTask(this),
       dietParser = new DietParserTask(this),
       parser = new ParserTask(this),
       patchParser = new PatchParserTask(this),
       resolver = new ResolverTask(this),
       closureToClassMapper = new closureMapping.ClosureTask(this, closureNamer),
       checker = new TypeCheckerTask(this),
       typesTask = new ti.TypesTask(this),
       containerTracer = new ContainerTracer(this),
@@ skipping 97 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).catchError((error) {

[ahe, 2013/09/02 13:43:24]

I think runCompiler needs to be wrapped in try-catch. I see several things that
can happen outside the future action.

Perhaps you can use Future.sync instead.

[Johnni Winther, 2013/09/03 07:51:39]

Done.

+      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 onLibraryLoaded(LibraryElement library, Uri uri) {
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (dynamicClass != null) {
       // When loading the built-in libraries, dynamicClass is null. We
       // take advantage of this as core imports js_helper and sees [dynamic]
       // this way.
       withCurrentElement(dynamicClass, () {
         library.addToScope(dynamicClass, this);
       });
     }
     if (uri == new Uri(scheme: 'dart', path: 'mirrors')) {
       mirrorsLibrary = library;
       mirrorSystemClass =
           findRequiredElement(library, const SourceString('MirrorSystem'));
       mirrorsUsedClass =
           findRequiredElement(library, const SourceString('MirrorsUsed'));
     } else if (uri == new Uri(scheme: 'dart', path: '_collection-dev')) {
       symbolImplementationClass =
           findRequiredElement(library, const SourceString('Symbol'));
     } else if (uri == new Uri(scheme: 'dart', path: 'async')) {
       deferredLibraryClass =
           findRequiredElement(library, const SourceString('DeferredLibrary'));
     } else if (isolateHelperLibrary == null
                && (uri == new Uri(scheme: 'dart', path: '_isolate_helper'))) {
-      isolateHelperLibrary = scanBuiltinLibrary('_isolate_helper');
+      isolateHelperLibrary = library;
     } else if (foreignLibrary == null
                && (uri == new Uri(scheme: 'dart', path: '_foreign_helper'))) {
-      foreignLibrary = scanBuiltinLibrary('_foreign_helper');
+      foreignLibrary = library;
     }
-    backend.onLibraryLoaded(library, uri);
+    return backend.onLibraryLoaded(library, uri);
   }
 
   Element findRequiredElement(LibraryElement library, SourceString name) {
     var element = library.find(name);
     if (element == null) {
       internalErrorOnElement(
           library,
           'The library "${library.canonicalUri}" does not contain required '
           'element: ${name.slowToString()}');
       }
     return element;
   }
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember(const SourceString('getName'));
     } else if (symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
       symbolValidatedConstructor = symbolImplementationClass.lookupConstructor(
           symbolValidatedConstructorSelector);
     } else if (mirrorsUsedClass == cls) {
       mirrorsUsedConstructor = cls.constructors.head;
     }
   }
 
-  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 57 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');
-    assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
-    identicalFunction = coreLibrary.find(const SourceString('identical'));
+  Future scanBuiltinLibraries() {
+    return scanBuiltinLibrary('_js_helper').then((LibraryElement library) {
+      jsHelperLibrary = library;
+      return scanBuiltinLibrary('_interceptors');
+    }).then((LibraryElement library) {
+      interceptorsLibrary = library;
 
-    initializeSpecialClasses();
+      assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
+      identicalFunction = coreLibrary.find(const SourceString('identical'));
 
-    functionClass.ensureResolved(this);
-    functionApplyMethod =
-        functionClass.lookupLocalMember(const SourceString('apply'));
-    jsInvocationMirrorClass.ensureResolved(this);
-    invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
+      initializeSpecialClasses();
 
-    if (preserveComments) {
-      var uri = new Uri(scheme: 'dart', path: 'mirrors');
-      LibraryElement libraryElement =
-          libraryLoader.loadLibrary(uri, null, uri);
-      documentClass = libraryElement.find(const SourceString('Comment'));
-    }
+      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');
+        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);
+    return scanBuiltinLibraries().then((_) {
+      if (librariesToAnalyzeWhenRun != null) {
+        return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
+          log('analyzing $libraryUri ($buildId)');
+          return libraryLoader.loadLibrary(libraryUri, null, libraryUri);
+        });
       }
-    }
-    if (uri != null) {
-      if (analyzeOnly) {
-        log('analyzing $uri ($buildId)');
-      } else {
-        log('compiling $uri ($buildId)');
+    }).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;
+        });
       }
-      mainApp = libraryLoader.loadLibrary(uri, null, uri);
-    }
+    }).then((_) {
+      compileLoadedLibraries();
+    });
+  }
+
+  /// Performs the compilation when all libraries have been loaded.
+  void compileLoadedLibraries() {
     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.'});
+              '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.'});
+                'Error: "${MAIN.slowToString()}" cannot have parameters.'});
         });
       }
 
       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
@@ skipping 36 matching lines @@
     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));
+      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib,
+          enqueuer.codegen));
     }
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
     backend.assembleProgram();
 
     checkQueues();
 
@@ skipping 306 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, [Element element, 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');
   }
 }