Remove scanBuiltinLibraries.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 35 matching lines @@
       // it outside a loop either.
       canBeInlined[element] = false;
       canBeInlinedInsideLoop[element] = false;
     } else {
       canBeInlined[element] = false;
     }
   }
 }
 
 class JavaScriptBackend extends Backend {
+  static final Uri DART_JS_MIRRORS =
+      new Uri(scheme: 'dart', path: '_js_mirrors');
+  static final Uri DART_JS_NAMES =
+      new Uri(scheme: 'dart', path: '_js_names');
+
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
@@ skipping 396 matching lines @@
       }
     }
     return result;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(
         operatorEqfunction.enclosingClass);
   }
 
-  void initializeHelperClasses() {
-    getInterceptorMethod = compiler.findInterceptor('getInterceptor');
-    interceptedNames = compiler.findInterceptor('interceptedNames');
-    mapTypeToInterceptor = compiler.findInterceptor('mapTypeToInterceptor');
-    getNativeInterceptorMethod =
-        compiler.findInterceptor('getNativeInterceptor');
-
-    // These methods are overwritten with generated versions.
-    inlineCache.markAsNonInlinable(getInterceptorMethod, insideLoop: true);
-
-    List<ClassElement> classes = [
-      jsInterceptorClass =
-          compiler.findInterceptor('Interceptor'),
-      jsStringClass = compiler.findInterceptor('JSString'),
-      jsArrayClass = compiler.findInterceptor('JSArray'),
-      // The int class must be before the double class, because the
-      // emitter relies on this list for the order of type checks.
-      jsIntClass = compiler.findInterceptor('JSInt'),
-      jsPositiveIntClass = compiler.findInterceptor('JSPositiveInt'),
-      jsUInt32Class = compiler.findInterceptor('JSUInt32'),
-      jsUInt31Class = compiler.findInterceptor('JSUInt31'),
-      jsDoubleClass = compiler.findInterceptor('JSDouble'),
-      jsNumberClass = compiler.findInterceptor('JSNumber'),
-      jsNullClass = compiler.findInterceptor('JSNull'),
-      jsBoolClass = compiler.findInterceptor('JSBool'),
-      jsMutableArrayClass = compiler.findInterceptor('JSMutableArray'),
-      jsFixedArrayClass = compiler.findInterceptor('JSFixedArray'),
-      jsExtendableArrayClass = compiler.findInterceptor('JSExtendableArray'),
-      jsPlainJavaScriptObjectClass =
-          compiler.findInterceptor('PlainJavaScriptObject'),
-      jsUnknownJavaScriptObjectClass =
-          compiler.findInterceptor('UnknownJavaScriptObject'),
-    ];
-
-    implementationClasses = <ClassElement, ClassElement>{};
-    implementationClasses[compiler.intClass] = jsIntClass;
-    implementationClasses[compiler.boolClass] = jsBoolClass;
-    implementationClasses[compiler.numClass] = jsNumberClass;
-    implementationClasses[compiler.doubleClass] = jsDoubleClass;
-    implementationClasses[compiler.stringClass] = jsStringClass;
-    implementationClasses[compiler.listClass] = jsArrayClass;
-    implementationClasses[compiler.nullClass] = jsNullClass;
-
-    jsIndexableClass = compiler.findInterceptor('JSIndexable');
-    jsMutableIndexableClass = compiler.findInterceptor('JSMutableIndexable');
-
-    // TODO(kasperl): Some tests do not define the special JSArray
-    // subclasses, so we check to see if they are defined before
-    // trying to resolve them.
-    if (jsFixedArrayClass != null) {
-      jsFixedArrayClass.ensureResolved(compiler);
-    }
-    if (jsExtendableArrayClass != null) {
-      jsExtendableArrayClass.ensureResolved(compiler);
-    }
-
-    jsIndexableClass.ensureResolved(compiler);
-    jsIndexableLength = compiler.lookupElementIn(
-        jsIndexableClass, 'length');
-    if (jsIndexableLength != null && jsIndexableLength.isAbstractField) {
-      AbstractFieldElement element = jsIndexableLength;
-      jsIndexableLength = element.getter;
-    }
-
-    jsArrayClass.ensureResolved(compiler);
-    jsArrayTypedConstructor = compiler.lookupElementIn(jsArrayClass, 'typed');
-    jsArrayRemoveLast = compiler.lookupElementIn(jsArrayClass, 'removeLast');
-    jsArrayAdd = compiler.lookupElementIn(jsArrayClass, 'add');
-
-    jsStringClass.ensureResolved(compiler);
-    jsStringSplit = compiler.lookupElementIn(jsStringClass, 'split');
-    jsStringOperatorAdd = compiler.lookupElementIn(jsStringClass, '+');
-    jsStringToString = compiler.lookupElementIn(jsStringClass, 'toString');
-
-    typeLiteralClass = compiler.findHelper('TypeImpl');
-    mapLiteralClass = compiler.coreLibrary.find('LinkedHashMap');
-    constMapLiteralClass = compiler.findHelper('ConstantMap');
-
-    objectEquals = compiler.lookupElementIn(compiler.objectClass, '==');
-
-    jsIndexingBehaviorInterface =
-        compiler.findHelper('JavaScriptIndexingBehavior');
-
-    specialOperatorEqClasses
-        ..add(compiler.objectClass)
-        ..add(jsInterceptorClass)
-        ..add(jsNullClass);
-
-    validateInterceptorImplementsAllObjectMethods(jsInterceptorClass);
-    // The null-interceptor must also implement *all* methods.
-    validateInterceptorImplementsAllObjectMethods(jsNullClass);
-
-    typeVariableClass = compiler.findHelper('TypeVariable');
-
-    indexablePrimitiveType = new TypeMask.nonNullSubtype(jsIndexableClass);
-    readableArrayType = new TypeMask.nonNullSubclass(jsArrayClass);
-    mutableArrayType = new TypeMask.nonNullSubclass(jsMutableArrayClass);
-    fixedArrayType = new TypeMask.nonNullExact(jsFixedArrayClass);
-    extendableArrayType = new TypeMask.nonNullExact(jsExtendableArrayClass);
-    nonNullType = compiler.typesTask.dynamicType.nonNullable();
-
-    noSideEffectsClass = compiler.findHelper('NoSideEffects');
-    noThrowsClass = compiler.findHelper('NoThrows');
-    noInlineClass = compiler.findHelper('NoInline');
-    irRepresentationClass = compiler.findHelper('IrRepresentation');
-  }
-
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(compiler);
     compiler.objectClass.forEachMember((_, Element member) {
       if (member.isGenerativeConstructor) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
       assert(interceptorMember.enclosingClass == interceptorClass);
@@ skipping 252 matching lines @@
     enqueueClass(enqueuer, jsPlainJavaScriptObjectClass, registry);
     needToInitializeIsolateAffinityTag = true;
     needToInitializeDispatchProperty = true;
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   void enqueueHelpers(ResolutionEnqueuer world, Registry registry) {
+    assert(compiler.interceptorsLibrary != null);
     // TODO(ngeoffray): Not enqueuing those two classes currently make
     // the compiler potentially crash. However, any reasonable program
     // will instantiate those two classes.
     addInterceptors(jsBoolClass, world, registry);
     addInterceptors(jsNullClass, world, registry);
     if (compiler.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e =
@@ skipping 823 matching lines @@
       for (MetadataAnnotation metadata in element.metadata) {
         metadata.ensureResolved(compiler);
         Constant constant = constants.getConstantForMetadata(metadata);
         constants.addCompileTimeConstantForEmission(constant);
       }
       return true;
     }
     return false;
   }
 
-  Future onLibraryLoaded(LibraryElement library, Uri uri) {
-    if (uri == Uri.parse('dart:_js_mirrors')) {
-      disableTreeShakingMarker =
-          library.find('disableTreeShaking');
-      preserveMetadataMarker =
-          library.find('preserveMetadata');
-    } else if (uri == Uri.parse('dart:_js_names')) {
-      preserveNamesMarker =
-          library.find('preserveNames');
-    } else if (uri == Uri.parse('dart:_js_helper')) {
-      getIsolateAffinityTagMarker =
-          library.find('getIsolateAffinityTag');
+  void onLibraryScanned(LibraryElement library) {
+    Uri uri = library.canonicalUri;
+
+    // TODO(johnniwinther): Assert that the elements are found.
+    VariableElement findVariable(String name) {
+      return library.find(name);
     }
+
+    FunctionElement findMethod(String name) {
+      return library.find(name);
+    }
+
+    ClassElement findClass(String name) {
+      return library.find(name);
+    }
+
+    if (uri == Compiler.DART_INTERCEPTORS) {
+      getInterceptorMethod = findMethod('getInterceptor');
+      interceptedNames = findVariable('interceptedNames');
+      mapTypeToInterceptor = findVariable('mapTypeToInterceptor');
+      getNativeInterceptorMethod = findMethod('getNativeInterceptor');
+
+      List<ClassElement> classes = [
+        jsInterceptorClass = findClass('Interceptor'),
+        jsStringClass = findClass('JSString'),
+        jsArrayClass = findClass('JSArray'),
+        // The int class must be before the double class, because the
+        // emitter relies on this list for the order of type checks.
+        jsIntClass = findClass('JSInt'),
+        jsPositiveIntClass = findClass('JSPositiveInt'),
+        jsUInt32Class = findClass('JSUInt32'),
+        jsUInt31Class = findClass('JSUInt31'),
+        jsDoubleClass = findClass('JSDouble'),
+        jsNumberClass = findClass('JSNumber'),
+        jsNullClass = findClass('JSNull'),
+        jsBoolClass = findClass('JSBool'),
+        jsMutableArrayClass = findClass('JSMutableArray'),
+        jsFixedArrayClass = findClass('JSFixedArray'),
+        jsExtendableArrayClass = findClass('JSExtendableArray'),
+        jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject'),
+        jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject'),
+      ];
+
+      jsIndexableClass = findClass('JSIndexable');
+      jsMutableIndexableClass = findClass('JSMutableIndexable');
+    } else if (uri == Compiler.DART_JS_HELPER) {
+      typeLiteralClass = findClass('TypeImpl');
+      constMapLiteralClass = findClass('ConstantMap');
+      typeVariableClass = findClass('TypeVariable');
+
+      jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
+
+      noSideEffectsClass = findClass('NoSideEffects');
+      noThrowsClass = findClass('NoThrows');
+      noInlineClass = findClass('NoInline');
+      irRepresentationClass = findClass('IrRepresentation');
+    } else if (uri == DART_JS_MIRRORS) {
+      disableTreeShakingMarker = library.find('disableTreeShaking');
+      preserveMetadataMarker = library.find('preserveMetadata');
+    } else if (uri == DART_JS_NAMES) {
+      preserveNamesMarker = library.find('preserveNames');
+    } else if (uri == Compiler.DART_JS_HELPER) {
+      getIsolateAffinityTagMarker = library.find('getIsolateAffinityTag');
+    }
+  }
+
+  Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
+    if (!loadedLibraries.containsKey(Compiler.DART_CORE)) {
+      return new Future.value();
+    }
+    assert(loadedLibraries.containsKey(Compiler.DART_CORE));
+    assert(loadedLibraries.containsKey(Compiler.DART_INTERCEPTORS));
+    assert(loadedLibraries.containsKey(Compiler.DART_JS_HELPER));
+
+    // [LinkedHashMap] is reexported from dart:collection and can therefore not
+    // be loaded from dart:core in [onLibraryScanned].
+    mapLiteralClass = compiler.coreLibrary.find('LinkedHashMap');
+
+    implementationClasses = <ClassElement, ClassElement>{};
+    implementationClasses[compiler.intClass] = jsIntClass;
+    implementationClasses[compiler.boolClass] = jsBoolClass;
+    implementationClasses[compiler.numClass] = jsNumberClass;
+    implementationClasses[compiler.doubleClass] = jsDoubleClass;
+    implementationClasses[compiler.stringClass] = jsStringClass;
+    implementationClasses[compiler.listClass] = jsArrayClass;
+    implementationClasses[compiler.nullClass] = jsNullClass;
+
+    // These methods are overwritten with generated versions.
+    inlineCache.markAsNonInlinable(getInterceptorMethod, insideLoop: true);
+
+    // TODO(kasperl): Some tests do not define the special JSArray
+    // subclasses, so we check to see if they are defined before
+    // trying to resolve them.
+    if (jsFixedArrayClass != null) {
+      jsFixedArrayClass.ensureResolved(compiler);
+    }
+    if (jsExtendableArrayClass != null) {
+      jsExtendableArrayClass.ensureResolved(compiler);
+    }
+
+    jsIndexableClass.ensureResolved(compiler);
+    jsIndexableLength = compiler.lookupElementIn(
+        jsIndexableClass, 'length');
+    if (jsIndexableLength != null && jsIndexableLength.isAbstractField) {
+      AbstractFieldElement element = jsIndexableLength;
+      jsIndexableLength = element.getter;
+    }
+
+    jsArrayClass.ensureResolved(compiler);
+    jsArrayTypedConstructor = compiler.lookupElementIn(jsArrayClass, 'typed');
+    jsArrayRemoveLast = compiler.lookupElementIn(jsArrayClass, 'removeLast');
+    jsArrayAdd = compiler.lookupElementIn(jsArrayClass, 'add');
+
+    jsStringClass.ensureResolved(compiler);
+    jsStringSplit = compiler.lookupElementIn(jsStringClass, 'split');
+    jsStringOperatorAdd = compiler.lookupElementIn(jsStringClass, '+');
+    jsStringToString = compiler.lookupElementIn(jsStringClass, 'toString');
+
+    objectEquals = compiler.lookupElementIn(compiler.objectClass, '==');
+
+    specialOperatorEqClasses
+        ..add(compiler.objectClass)
+        ..add(jsInterceptorClass)
+        ..add(jsNullClass);
+
+    indexablePrimitiveType = new TypeMask.nonNullSubtype(jsIndexableClass);
+    readableArrayType = new TypeMask.nonNullSubclass(jsArrayClass);
+    mutableArrayType = new TypeMask.nonNullSubclass(jsMutableArrayClass);
+    fixedArrayType = new TypeMask.nonNullExact(jsFixedArrayClass);
+    extendableArrayType = new TypeMask.nonNullExact(jsExtendableArrayClass);
+    nonNullType = compiler.typesTask.dynamicType.nonNullable();
+
+    validateInterceptorImplementsAllObjectMethods(jsInterceptorClass);
+    // The null-interceptor must also implement *all* methods.
+    validateInterceptorImplementsAllObjectMethods(jsNullClass);
     return new Future.value();
   }
 
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
                            Set<Element> metaTargets) {
     if (symbols == null && targets == null && metaTargets == null) {
       // The user didn't specify anything, or there are imports of
       // 'dart:mirrors' without @MirrorsUsed.
       hasInsufficientMirrorsUsed = true;
@@ skipping 238 matching lines @@
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }