Remove scanBuiltinLibraries.

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 379 matching lines @@
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
     ClassElement classElement = element.enclosingClass;
     return classElement == compiler.objectClass;
   }
 
   bool isInterceptorClass(ClassElement element) => false;
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
-  Future onLibraryLoaded(LibraryElement library, Uri uri) {
+  void onLibraryCreated(LibraryElement library) {}
+
+  void onLibraryScanned(LibraryElement library) {}
+
+  Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     return new Future.value();
   }
 
   /// 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,
                            Set<Element> metaTargets) {}
 
@@ skipping 62 matching lines @@
 
 abstract class Compiler implements DiagnosticListener {
   static final Uri DART_CORE = new Uri(scheme: 'dart', path: 'core');
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
+  static final Uri DART_MIRRORS = new Uri(scheme: 'dart', path: 'mirrors');
+  static final Uri DART_NATIVE_TYPED_DATA =
+      new Uri(scheme: 'dart', path: '_native_typed_data');
+  static final Uri DART_INTERNAL = new Uri(scheme: 'dart', path: '_internal');
+  static final Uri DART_ASYNC = new Uri(scheme: 'dart', path: 'async');
+
+  // TODO(johnniwinther): Change to map from [Uri] to [LibraryElement].
   final Map<String, LibraryElement> libraries =
     new Map<String, LibraryElement>();
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
 
   /**
    * Map from token to the first preceeding comment token.
@@ skipping 100 matching lines @@
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
   LibraryElement coreLibrary;
   LibraryElement isolateLibrary;
   LibraryElement isolateHelperLibrary;
+  // TODO(johnniwinther): Move JavaScript specific libraries to the JavaScript
+  // backend.
   LibraryElement jsHelperLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   /// Initialized when dart:mirrors is loaded.
   LibraryElement mirrorsLibrary;
 
@@ skipping 177 matching lines @@
 
   bool hasCrashed = false;
 
   /// Set by the backend if real reflection is detected in use of dart:mirrors.
   bool disableTypeInferenceForMirrors = false;
 
   Compiler({this.enableTypeAssertions: false,
             this.enableUserAssertions: false,
             this.trustTypeAnnotations: false,
             this.enableConcreteTypeInference: false,
-            this.disableTypeInferenceFlag: false,
+            bool disableTypeInferenceFlag: false,
             this.maxConcreteTypeSize: 5,
             this.enableMinification: false,
             this.enableNativeLiveTypeAnalysis: false,
             bool emitJavaScript: true,
             bool generateSourceMap: true,
             bool analyzeAllFlag: false,
             bool analyzeOnly: false,
             this.analyzeMain: false,
             bool analyzeSignaturesOnly: false,
             this.preserveComments: false,
             this.verbose: false,
             this.sourceMapUri: null,
             this.outputUri: null,
             this.buildId: UNDETERMINED_BUILD_ID,
             this.terseDiagnostics: false,
             this.disableDeferredLoading: false,
             this.dumpInfo: false,
             this.showPackageWarnings: false,
             this.useContentSecurityPolicy: false,
             this.suppressWarnings: false,
             outputProvider,
             List<String> strips: const []})
-      : this.analyzeOnly =
+      : this.disableTypeInferenceFlag =
+          disableTypeInferenceFlag || !emitJavaScript,
+        this.analyzeOnly =
             analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
         this.analyzeSignaturesOnly = analyzeSignaturesOnly,
         this.analyzeAllFlag = analyzeAllFlag,
         this.outputProvider = (outputProvider == null)
             ? NullSink.outputProvider
             : outputProvider {
     world = new World(this);
+    types = new Types(this);
     tracer = new Tracer(this.outputProvider);
 
     closureMapping.ClosureNamer closureNamer;
     if (emitJavaScript) {
       js_backend.JavaScriptBackend jsBackend =
           new js_backend.JavaScriptBackend(this, generateSourceMap);
       closureNamer = jsBackend.namer;
       backend = jsBackend;
     } else {
       closureNamer = new closureMapping.ClosureNamer();
@@ skipping 138 matching lines @@
     }).whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
     }).then((_) {
       return !compilationFailed;
     });
   }
 
   bool hasIsolateSupport() => isolateLibrary != null;
 
-  /**
-   * This method is called before [library] import and export scopes have been
-   * set up.
-   */
-  Future onLibraryLoaded(LibraryElement library, Uri uri) {
-    if (uri == new Uri(scheme: 'dart', path: 'mirrors')) {
+  /// This method is called immediately after the [LibraryElement] [library] has

[karlklose, 2014/06/17 12:30:25]

Move first part of the comments to the abstract class.

[Johnni Winther, 2014/06/17 12:52:28]

Done.

+  /// been created.
+  ///
+  /// Use this callback method to store references to specific libraries.
+  /// Note that [library] has not been scanned yet, nor has its imports/exports
+  /// been resolved.
+  void onLibraryCreated(LibraryElement library) {
+    Uri uri = library.canonicalUri;
+    if (uri == DART_CORE) {
+      coreLibrary = library;
+    } else if (uri == DART_JS_HELPER) {
+      jsHelperLibrary = library;
+    } else if (uri == DART_INTERCEPTORS) {
+      interceptorsLibrary = library;
+    } else if (uri == DART_FOREIGN_HELPER) {
+      foreignLibrary = library;
+    } else if (uri == DART_ISOLATE_HELPER) {
+      isolateHelperLibrary = library;
+    } else if (uri == DART_NATIVE_TYPED_DATA) {
+      typedDataLibrary = library;
+    } else if (uri == DART_MIRRORS) {
       mirrorsLibrary = library;
-      mirrorSystemClass =
-          findRequiredElement(library, 'MirrorSystem');
-      mirrorsUsedClass =
-          findRequiredElement(library, 'MirrorsUsed');
-    } else if (uri == new Uri(scheme: 'dart', path: '_native_typed_data')) {
-      typedDataLibrary = library;
-      typedDataClass =
-          findRequiredElement(library, 'NativeTypedData');
-    } else if (uri == new Uri(scheme: 'dart', path: '_internal')) {
-      symbolImplementationClass =
-          findRequiredElement(library, 'Symbol');
-    } else if (uri == new Uri(scheme: 'dart', path: 'async')) {
-      deferredLibraryClass =
-          findRequiredElement(library, 'DeferredLibrary');
-    } else if (isolateHelperLibrary == null
-               && (uri == new Uri(scheme: 'dart', path: '_isolate_helper'))) {
-      isolateHelperLibrary = library;
-    } else if (foreignLibrary == null
-               && (uri == new Uri(scheme: 'dart', path: '_foreign_helper'))) {
-      foreignLibrary = library;
     }
-    return backend.onLibraryLoaded(library, uri);
+    backend.onLibraryCreated(library);
+  }
+
+  /// This method is called immediately after the [library] and its parts have
+  /// been scanned.
+  ///
+  /// Use this callback method to store references to specific member declared
+  /// in certain libraries. Note that [library] has not been patched yet, nor
+  /// has its imports/exports been resolved.
+  void onLibraryScanned(LibraryElement library) {
+    Uri uri = library.canonicalUri;
+    if (uri == DART_CORE) {
+      initializeCoreClasses();
+      identicalFunction = coreLibrary.find('identical');
+    } else if (uri == DART_JS_HELPER) {
+      initializeHelperClasses();
+      assertMethod = jsHelperLibrary.find('assertHelper');
+    } else if (uri == DART_INTERNAL) {
+      symbolImplementationClass = findRequiredElement(library, 'Symbol');
+    } else if (uri == DART_MIRRORS) {
+      mirrorSystemClass = findRequiredElement(library, 'MirrorSystem');
+      mirrorsUsedClass = findRequiredElement(library, 'MirrorsUsed');
+    } else if (uri == DART_ASYNC) {
+      deferredLibraryClass = findRequiredElement(library, 'DeferredLibrary');
+    } else if (uri == DART_NATIVE_TYPED_DATA) {
+      typedDataClass = findRequiredElement(library, 'NativeTypedData');
+    }
+    backend.onLibraryScanned(library);
+  }
+
+  /// This method is called when all new libraries loaded through
+  /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
+  /// have been computed.
+  ///
+  /// [loadedLibraries] contains the newly loaded libraries.
+  ///
+  /// The method returns a [Future] allowing for the loading of additional
+  /// libraries.
+  Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
+    return new Future.sync(() {
+      if (!loadedLibraries.containsKey(DART_CORE)) return new Future.value();
+
+      functionClass.ensureResolved(this);
+      functionApplyMethod = functionClass.lookupLocalMember('apply');
+
+      proxyConstant =
+          resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
+
+      if (jsInvocationMirrorClass != null) {
+        jsInvocationMirrorClass.ensureResolved(this);
+        invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
+      }
+
+      if (preserveComments) {
+        return libraryLoader.loadLibrary(DART_MIRRORS)
+            .then((LibraryElement libraryElement) {
+          documentClass = libraryElement.find('Comment');
+        });
+      }
+    }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
     if (element == null) {
       internalError(library,
           "The library '${library.canonicalUri}' does not contain required "
           "element: '$name'.");
       }
     return element;
@@ skipping 13 matching lines @@
     } else if (intClass == cls) {
       intEnvironment = intClass.lookupConstructor(fromEnvironmentSelector);
     } else if (stringClass == cls) {
       stringEnvironment =
           stringClass.lookupConstructor(fromEnvironmentSelector);
     } else if (boolClass == cls) {
       boolEnvironment = boolClass.lookupConstructor(fromEnvironmentSelector);
     }
   }
 
-  Future<LibraryElement> scanBuiltinLibrary(String filename);
-
-  void initializeSpecialClasses() {
+  void initializeCoreClasses() {
     final List missingCoreClasses = [];
     ClassElement lookupCoreClass(String name) {
       ClassElement result = coreLibrary.find(name);
       if (result == null) {
         missingCoreClasses.add(name);
       }
       return result;
     }
     objectClass = lookupCoreClass('Object');
     boolClass = lookupCoreClass('bool');
@@ skipping 10 matching lines @@
     if (!missingCoreClasses.isEmpty) {
       internalError(coreLibrary,
           'dart:core library does not contain required classes: '
           '$missingCoreClasses');
     }
 
     // The Symbol class may not exist during unit testing.
     // TODO(ahe): It is possible that we have to require the presence
     // of Symbol as we change how we implement noSuchMethod.
     symbolClass = lookupCoreClass('Symbol');
+  }
 
+  void initializeHelperClasses() {
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
       ClassElement result = jsHelperLibrary.find(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
       internalError(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
-
-    if (types == null) {
-      types = new Types(this);
-    }
-    backend.initializeHelperClasses();
-
-    proxyConstant =
-        resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         "", listClass.library);
     return _unnamedListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
 
   Element _filledListConstructor;
   Element get filledListConstructor {
     if (_filledListConstructor != null) return _filledListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         "filled", listClass.library);
     return _filledListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
 
-  Future scanBuiltinLibraries() {
-    return scanBuiltinLibrary('_js_helper').then((LibraryElement library) {
-      jsHelperLibrary = library;
-      return scanBuiltinLibrary('_interceptors');
-    }).then((LibraryElement library) {
-      interceptorsLibrary = library;
-
-      assertMethod = jsHelperLibrary.find('assertHelper');
-      identicalFunction = coreLibrary.find('identical');
-
-      initializeSpecialClasses();
-
-      functionClass.ensureResolved(this);
-      functionApplyMethod =
-          functionClass.lookupLocalMember('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('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);
 
   Future runCompiler(Uri uri) {
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times. Implement a better mechanism where we can store
     // such caches in the compiler and get access to them through a
     // suitably maintained static reference to the current compiler.
     StringToken.canonicalizedSubstrings.clear();
     Selector.canonicalizedValues.clear();
     TypedSelector.canonicalizedValues.clear();
 
     assert(uri != null || analyzeOnly);
-    return scanBuiltinLibraries().then((_) {
+    return new Future.sync(() {
       if (librariesToAnalyzeWhenRun != null) {
         return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
           log('Analyzing $libraryUri ($buildId)');
-          return libraryLoader.loadLibrary(libraryUri, null, libraryUri);
+          return libraryLoader.loadLibrary(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) {
+        return libraryLoader.loadLibrary(uri).then((LibraryElement library) {
           mainApp = library;
         });
       }
     }).then((_) {
-      compileLoadedLibraries();
+      if (!compilationFailed) {
+        // TODO(johnniwinther): Reenable analysis of programs with load failures
+        // when these are handled as erroneous libraries/compilation units.
+        compileLoadedLibraries();
+      }
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() {
     Element main = null;
     if (mainApp != null) {
       main = mainApp.findExported(MAIN);
       if (main == null) {
         if (!analyzeOnly) {
@@ skipping 742 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }