First pass at asynchronous input loading in dart2js.

tests/compiler/dart2js/mock_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.
 
 library mock_compiler;
 
 import "package:expect/expect.dart";
+import 'dart:async';
 import 'dart:collection';
 
 import '../../../sdk/lib/_internal/compiler/compiler.dart' as api;
 import '../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/resolution/resolution.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/util/util.dart';
 import 'parser_helper.dart';
 
@@ skipping 199 matching lines @@
       : warnings = [], errors = [],
         sourceFiles = new Map<String, SourceFile>(),
         super(enableTypeAssertions: enableTypeAssertions,
               enableMinification: enableMinification,
               enableConcreteTypeInference: enableConcreteTypeInference,
               maxConcreteTypeSize: maxConcreteTypeSize,
               disableTypeInferenceFlag: disableTypeInference,
               analyzeAllFlag: analyzeAll,
               analyzeOnly: analyzeOnly,
               preserveComments: preserveComments) {
-    coreLibrary = createLibrary("core", coreSource);
+    coreLibrary = deprecatedFutureValue(createLibrary("core", coreSource));
+
     // We need to set the assert method to avoid calls with a 'null'
     // target being interpreted as a call to assert.
-    jsHelperLibrary = createLibrary("helper", helperSource);
-    foreignLibrary = createLibrary("foreign", FOREIGN_LIBRARY);
-    interceptorsLibrary = createLibrary("interceptors", interceptorsSource);
-    isolateHelperLibrary = createLibrary("isolate_helper", isolateHelperSource);
+    jsHelperLibrary = deprecatedFutureValue(createLibrary("helper", helperSource));
+    foreignLibrary = deprecatedFutureValue(createLibrary("foreign", FOREIGN_LIBRARY));
+    interceptorsLibrary = deprecatedFutureValue(createLibrary("interceptors", interceptorsSource));
+    isolateHelperLibrary = deprecatedFutureValue(createLibrary("isolate_helper", isolateHelperSource));
 
     // Set up the library imports.
     importHelperLibrary(coreLibrary);
     libraryLoader.importLibrary(jsHelperLibrary, coreLibrary, null);
     libraryLoader.importLibrary(interceptorsLibrary, coreLibrary, null);
     libraryLoader.importLibrary(isolateHelperLibrary, coreLibrary, null);
 
     assertMethod = jsHelperLibrary.find(buildSourceString('assert'));
     identicalFunction = coreLibrary.find(buildSourceString('identical'));
 
@@ skipping 17 matching lines @@
    * library.
    */
   void registerSource(Uri uri, String source) {
     sourceFiles[uri.toString()] = new MockFile(source);
   }
 
   /**
    * Used internally to create a library from a source text. The created library
    * is fixed to export its top-level declarations.
    */
-  LibraryElement createLibrary(String name, String source) {
+  Future<LibraryElement> createLibrary(String name, String source) {
     Uri uri = new Uri(scheme: "dart", path: name);
     var script = new Script(uri, new MockFile(source));
     var library = new LibraryElementX(script);
     parseScript(source, library);
     library.setExports(library.localScope.values.toList());
     registerSource(uri, source);
     libraries.putIfAbsent(uri.toString(), () => library);
-    return library;
+    return new Future.value(library);
   }
 
   void reportWarning(Node node, var message) {
     if (message is! Message) message = message.message;
     warnings.add(new WarningMessage(node, message));
     reportDiagnostic(spanFromNode(node),
         'Warning: $message', api.Diagnostic.WARNING);
   }
 
   void reportError(Node node, var message) {
@@ skipping 62 matching lines @@
                             new CollectingTreeElements(mockElement));
     visitor.scope = new MethodScope(visitor.scope, mockElement);
     return visitor;
   }
 
   parseScript(String text, [LibraryElement library]) {
     if (library == null) library = mainApp;
     parseUnit(text, this, library, registerSource);
   }
 
-  void scanBuiltinLibraries() {
+  Future scanBuiltinLibraries() {
     // Do nothing. The mock core library is already handled in the constructor.
+    return new Future.value();
   }
 
-  LibraryElement scanBuiltinLibrary(String name) {
+  Future<LibraryElement> scanBuiltinLibrary(String name) {
     // Do nothing. The mock core library is already handled in the constructor.
+    return new Future.value();
   }
 
   void importCoreLibrary(LibraryElement library) {
     scanner.importLibrary(library, coreLibrary, null);
   }
 
   Uri translateResolvedUri(LibraryElement importingLibrary,
                            Uri resolvedUri, Node node) => resolvedUri;
 
   // The mock library doesn't need any patches.
   Uri resolvePatchUri(String dartLibraryName) => null;
 
-  Script readScript(Uri uri, [Node node]) {
+  Future<Script> readScript(Uri uri, [Node node]) {
     SourceFile sourceFile = sourceFiles[uri.toString()];
     if (sourceFile == null) throw new ArgumentError(uri);
-    return new Script(uri, sourceFile);
+    return new Future.value(new Script(uri, sourceFile));
   }
 
   Element lookupElementIn(ScopeContainerElement container, name) {
     Element element = container.localLookup(name);
     return element != null
         ? element
         : new ErroneousElementX(null, null, name, container);
   }
 }
 
@@ skipping 52 matching lines @@
   }
 }
 
 class MockDeferredLoadTask extends DeferredLoadTask {
   MockDeferredLoadTask(Compiler compiler) : super(compiler);
 
   void registerMainApp(LibraryElement mainApp) {
     // Do nothing.
   }
 }