Avoid eager enqueueing from resolution

pkg/compiler/lib/src/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 1400 matching lines @@
         Element element = find(isolateHelperLibrary, name);
         enqueuer.addToWorkList(element);
         compiler.globalDependencies.registerDependency(element);
         helpersUsed.add(element.declaration);
       }
     } else {
       enqueuer.addToWorkList(find(isolateHelperLibrary, START_ROOT_ISOLATE));
     }
   }
 
-  void registerRequiredType(DartType type, Element enclosingElement) {
+  void registerRequiredType(DartType type) {
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
     // defined (that is the enclosing class of the current element being
     // resolved) and the class of [type]. If the class of [type] requires RTI,
     // then the class of the type variable does too.
     ClassElement contextClass = Types.getClassContext(type);
     if (contextClass != null) {
-      assert(contextClass == enclosingElement.enclosingClass.declaration);
       rti.registerRtiDependency(type.element, contextClass);
     }
   }
 
   bool classNeedsRti(ClassElement cls) {
     return rti.classesNeedingRti.contains(cls.declaration) ||
         compiler.enabledRuntimeType;
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
@@ skipping 978 matching lines @@
     for (ClassElement cls in resolution.universe.directlyInstantiatedClasses) {
       // Do not process internal classes.
       if (cls.library.isInternalLibrary || cls.isInjected) continue;
       if (referencedFromMirrorSystem(cls)) {
         Set<Name> memberNames = new Set<Name>();
         // 1) the class (should be resolved)
         assert(invariant(cls, cls.isResolved));
         reflectableMembers.add(cls);
         // 2) its constructors (if resolved)
         cls.constructors.forEach((Element constructor) {
-          if (resolution.hasBeenResolved(constructor)) {
+          if (resolution.hasBeenProcessed(constructor)) {
             reflectableMembers.add(constructor);
           }
         });
         // 3) all members, including fields via getter/setters (if resolved)
         cls.forEachClassMember((Member member) {
-          if (resolution.hasBeenResolved(member.element)) {
+          if (resolution.hasBeenProcessed(member.element)) {
             memberNames.add(member.name);
             reflectableMembers.add(member.element);
           }
         });
         // 4) all overriding members of subclasses/subtypes (should be resolved)
         if (compiler.world.hasAnyStrictSubtype(cls)) {
           for (ClassElement subcls in compiler.world.strictSubtypesOf(cls)) {
             subcls.forEachClassMember((Member member) {
               if (memberNames.contains(member.name)) {
                 // TODO(20993): find out why this assertion fails.
                 // assert(invariant(member.element,
-                //    resolution.hasBeenResolved(member.element)));
-                if (resolution.hasBeenResolved(member.element)) {
+                //    resolution.hasBeenProcessed(member.element)));
+                if (resolution.hasBeenProcessed(member.element)) {
                   reflectableMembers.add(member.element);
                 }
               }
             });
           }
         }
         // 5) all its closures
         List<LocalFunctionElement> closures = closureMap[cls];
         if (closures != null) {
           reflectableMembers.addAll(closures);
           foundClosure = true;
         }
       } else {
         // check members themselves
         cls.constructors.forEach((ConstructorElement element) {
-          if (!resolution.hasBeenResolved(element)) return;
+          if (!resolution.hasBeenProcessed(element)) return;
           if (referencedFromMirrorSystem(element, false)) {
             reflectableMembers.add(element);
           }
         });
         cls.forEachClassMember((Member member) {
-          if (!resolution.hasBeenResolved(member.element)) return;
+          if (!resolution.hasBeenProcessed(member.element)) return;
           if (referencedFromMirrorSystem(member.element, false)) {
             reflectableMembers.add(member.element);
           }
         });
         // Also add in closures. Those might be reflectable is their enclosing
         // member is.
         List<LocalFunctionElement> closures = closureMap[cls];
         if (closures != null) {
           for (LocalFunctionElement closure in closures) {
             if (referencedFromMirrorSystem(closure.memberContext, false)) {
               reflectableMembers.add(closure);
               foundClosure = true;
             }
           }
         }
       }
     }
     // We also need top-level non-class elements like static functions and
     // global fields. We use the resolution queue to decide which elements are
     // part of the live world.
     for (LibraryElement lib in compiler.libraryLoader.libraries) {
       if (lib.isInternalLibrary) continue;
       lib.forEachLocalMember((Element member) {
         if (!member.isClass &&
-            resolution.hasBeenResolved(member) &&
+            resolution.hasBeenProcessed(member) &&
             referencedFromMirrorSystem(member)) {
           reflectableMembers.add(member);
         }
       });
     }
     // And closures inside top-level elements that do not have a surrounding
     // class. These will be in the [:null:] bucket of the [closureMap].
     if (closureMap.containsKey(null)) {
       for (Element closure in closureMap[null]) {
         if (referencedFromMirrorSystem(closure)) {
@@ skipping 138 matching lines @@
       // necessary, but the backend relies on them being resolved.
       enqueuer.enqueueReflectiveStaticFields(_findStaticFieldTargets());
     }
 
     if (mustPreserveNames) compiler.log('Preserving names.');
 
     if (mustRetainMetadata) {
       compiler.log('Retaining metadata.');
 
       compiler.libraryLoader.libraries.forEach(retainMetadataOf);
-      if (!enqueuer.isResolutionQueue) {
+      if (enqueuer.isResolutionQueue) {
         for (Dependency dependency in metadataConstants) {
           registerCompileTimeConstant(
               dependency.constant,
+              new EagerRegistry(compiler,
+                  dependency.annotatedElement.analyzableElement.treeElements),
+              addForEmission: false);
+        }
+      } else {
+        for (Dependency dependency in metadataConstants) {
+          registerCompileTimeConstant(
+              dependency.constant,
               new CodegenRegistry(compiler,
                   dependency.annotatedElement.analyzableElement.treeElements),
               addForEmission: false);
         }
         metadataConstants.clear();
       }
     }
     return true;
   }
 
@@ skipping 123 matching lines @@
         : "out";
     String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
     String extension = addExtension ? ".part.js" : "";
     return "${outName}_$name$extension";
   }
 
   void registerAsyncMarker(FunctionElement element,
                            Enqueuer enqueuer,
                            Registry registry) {
     if (element.asyncMarker == AsyncMarker.ASYNC) {
-      enqueue(enqueuer, getAsyncHelper(), registry);
-      enqueue(enqueuer, getSyncCompleterConstructor(), registry);
-      enqueue(enqueuer, getStreamIteratorConstructor(), registry);
-      enqueue(enqueuer, getWrapBody(), registry);
+      _registerAsync(enqueuer, registry);
     } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
-      ClassElement clsSyncStarIterable = getSyncStarIterable();
-      clsSyncStarIterable.ensureResolved(resolution);
-      registerInstantiatedType(clsSyncStarIterable.rawType, enqueuer, registry);
-      enqueue(enqueuer, getSyncStarIterableConstructor(), registry);
-      enqueue(enqueuer, getEndOfIteration(), registry);
-      enqueue(enqueuer, getYieldStar(), registry);
-      enqueue(enqueuer, getSyncStarUncaughtError(), registry);
+      _registerSyncStar(enqueuer, registry);
     } else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
-      ClassElement clsASyncStarController = getASyncStarController();
-      clsASyncStarController.ensureResolved(resolution);
-      registerInstantiatedType(
-          clsASyncStarController.rawType, enqueuer, registry);
-      enqueue(enqueuer, getAsyncStarHelper(), registry);
-      enqueue(enqueuer, getStreamOfController(), registry);
-      enqueue(enqueuer, getYieldSingle(), registry);
-      enqueue(enqueuer, getYieldStar(), registry);
-      enqueue(enqueuer, getASyncStarControllerConstructor(), registry);
-      enqueue(enqueuer, getStreamIteratorConstructor(), registry);
-      enqueue(enqueuer, getWrapBody(), registry);
+      _registerAsyncStar(enqueuer, registry);
     }
   }
 
+  void _registerAsync(Enqueuer enqueuer,
+                      Registry registry) {
+    enqueue(enqueuer, getAsyncHelper(), registry);
+    enqueue(enqueuer, getSyncCompleterConstructor(), registry);
+    enqueue(enqueuer, getStreamIteratorConstructor(), registry);
+    enqueue(enqueuer, getWrapBody(), registry);
+  }
+
+  void _registerSyncStar(Enqueuer enqueuer,
+                         Registry registry) {
+    ClassElement clsSyncStarIterable = getSyncStarIterable();
+    clsSyncStarIterable.ensureResolved(compiler.resolution);
+    registerInstantiatedType(clsSyncStarIterable.rawType, enqueuer, registry);
+    enqueue(enqueuer, getSyncStarIterableConstructor(), registry);
+    enqueue(enqueuer, getEndOfIteration(), registry);
+    enqueue(enqueuer, getYieldStar(), registry);
+    enqueue(enqueuer, getSyncStarUncaughtError(), registry);
+  }
+
+  void _registerAsyncStar(Enqueuer enqueuer,
+                          Registry registry) {
+    ClassElement clsASyncStarController = getASyncStarController();
+    clsASyncStarController.ensureResolved(compiler.resolution);
+    registerInstantiatedType(
+        clsASyncStarController.rawType, enqueuer, registry);
+    enqueue(enqueuer, getAsyncStarHelper(), registry);
+    enqueue(enqueuer, getStreamOfController(), registry);
+    enqueue(enqueuer, getYieldSingle(), registry);
+    enqueue(enqueuer, getYieldStar(), registry);
+    enqueue(enqueuer, getASyncStarControllerConstructor(), registry);
+    enqueue(enqueuer, getStreamIteratorConstructor(), registry);
+    enqueue(enqueuer, getWrapBody(), registry);
+  }
+
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     registerCheckDeferredIsLoaded(registry);
     return true;
   }
 
   @override
   bool enableCodegenWithErrorsIfSupported(Spannable node) {
     if (compiler.useCpsIr) {
       compiler.reportHintMessage(
@@ skipping 136 matching lines @@
       return false;
     });
   }
 }
 
 class JavaScriptResolutionCallbacks extends ResolutionCallbacks {
   final JavaScriptBackend backend;
 
   JavaScriptResolutionCallbacks(this.backend);
 
+  WorldImpact transformImpact(ResolutionWorldImpact worldImpact) {
+    TransformedWorldImpact transformed =
+        new TransformedWorldImpact(worldImpact);
+    for (Feature feature in worldImpact.features) {
+      switch (feature) {
+        case Feature.ABSTRACT_CLASS_INSTANTIATION:
+          onAbstractClassInstantiation(transformed);
+          break;
+        case Feature.ASSERT:
+          onAssert(false, transformed);
+          break;
+        case Feature.ASSERT_WITH_MESSAGE:
+          onAssert(true, transformed);
+          break;
+        case Feature.ASYNC:
+          backend._registerAsync(
+              backend.compiler.enqueuer.resolution, transformed);
+          break;
+        case Feature.ASYNC_FOR_IN:
+          onAsyncForIn(null, transformed);
+          break;
+        case Feature.ASYNC_STAR:
+          backend._registerAsyncStar(
+              backend.compiler.enqueuer.resolution, transformed);
+          break;
+        case Feature.CATCH_STATEMENT:
+          onCatchStatement(transformed);
+          break;
+        case Feature.COMPILE_TIME_ERROR:
+          onCompileTimeError(transformed, null);
+          break;
+        case Feature.FALL_THROUGH_ERROR:
+          onFallThroughError(transformed);
+          break;
+        case Feature.INC_DEC_OPERATION:
+          onIncDecOperation(transformed);
+          break;
+        case Feature.LAZY_FIELD:
+          onLazyField(transformed);
+          break;
+        case Feature.NEW_SYMBOL:
+          backend.registerNewSymbol(transformed);
+          break;
+        case Feature.STACK_TRACE_IN_CATCH:
+          onStackTraceInCatch(transformed);
+          break;
+        case Feature.STRING_INTERPOLATION:
+          onStringInterpolation(transformed);
+          break;
+        case Feature.SUPER_NO_SUCH_METHOD:
+          onSuperNoSuchMethod(transformed);
+          break;
+        case Feature.SYMBOL_CONSTRUCTOR:
+          onSymbolConstructor(transformed);
+          break;
+        case Feature.SYNC_FOR_IN:
+          onSyncForIn(transformed);
+          break;
+        case Feature.SYNC_STAR:
+          backend._registerSyncStar(
+              backend.compiler.enqueuer.resolution, transformed);
+          break;
+        case Feature.THROW_EXPRESSION:
+          onThrowExpression(transformed);
+          break;
+        case Feature.THROW_NO_SUCH_METHOD:
+          onThrowNoSuchMethod(transformed);
+          break;
+        case Feature.THROW_RUNTIME_ERROR:
+          onThrowRuntimeError(transformed);
+          break;
+        case Feature.TYPE_VARIABLE_BOUNDS_CHECK:
+          onTypeVariableBoundCheck(transformed);
+          break;
+      }
+    }
+    for (DartType type in worldImpact.isChecks) {
+      onIsCheck(type, transformed);
+    }
+    for (DartType type in worldImpact.asCasts) {
+      onIsCheck(type, transformed);
+      onAsCheck(type, transformed);
+    }
+    if (backend.compiler.enableTypeAssertions) {
+      for (DartType type in worldImpact.checkedModeChecks) {
+        onIsCheck(type, transformed);
+      }
+    }
+    for (DartType requiredType in worldImpact.requiredTypes) {
+      backend.registerRequiredType(requiredType);
+    }
+    for (MapLiteralUse mapLiteralUse in worldImpact.mapLiterals) {
+      // TODO(johnniwinther): Use the [isEmpty] property when factory
+      // constructors are registered directly.
+      onMapLiteral(transformed, mapLiteralUse.type, mapLiteralUse.isConstant);
+    }
+    for (ListLiteralUse listLiteralUse in worldImpact.listLiterals) {
+      // TODO(johnniwinther): Use the [isConstant] and [isEmpty] property when
+      // factory constructors are registered directly.
+      transformed.registerInstantiation(listLiteralUse.type);
+    }
+    for (DartType typeLiteral in worldImpact.typeLiterals) {
+      onTypeLiteral(typeLiteral, transformed);
+      transformed.registerInstantiation(backend.compiler.coreTypes.typeType);
+      if (typeLiteral.isTypeVariable) {
+        onTypeVariableExpression(transformed, typeLiteral.element);
+      }
+    }
+    for (String constSymbolName in worldImpact.constSymbolNames) {
+      backend.registerConstSymbol(constSymbolName, transformed);
+    }
+    for (LocalFunctionElement closure in worldImpact.closures) {
+      if (closure.computeType(backend.resolution).containsTypeVariables) {
+        backend.registerClosureWithFreeTypeVariables(
+            closure, backend.compiler.enqueuer.resolution, transformed);
+      }
+    }
+    // TODO(johnniwinther): Remove this when dependency tracking is done on
+    // the world impact itself.
+    for (InterfaceType instantiatedType in worldImpact.instantiatedTypes) {
+      transformed.registerInstantiation(instantiatedType);
+    }
+
+    return transformed;
+  }
+
   void registerBackendStaticInvocation(Element element, Registry registry) {
     registry.registerStaticInvocation(backend.registerBackendUse(element));
   }
 
   void registerBackendInstantiation(ClassElement element, Registry registry) {
     backend.registerBackendUse(element);
     element.ensureResolved(backend.resolution);
     registry.registerInstantiation(element.rawType);
   }
 
@@ skipping 185 matching lines @@
             Identifiers.noSuchMethod_),
         registry);
     needsInt(registry,
         'Needed to encode the invocation kind of super.noSuchMethod.');
     needsList(registry,
         'Needed to encode the arguments of super.noSuchMethod.');
     needsString(registry,
         'Needed to encode the name of super.noSuchMethod.');
   }
 
-  void onMapLiteral(ResolutionRegistry registry,
+  void onMapLiteral(Registry registry,
                     DartType type,
                     bool isConstant) {
     assert(registry.isForResolution);
     void enqueue(String name) {
       Element e = backend.find(backend.jsHelperLibrary, name);
       registerBackendInstantiation(e, registry);
     }
 
     if (isConstant) {
       enqueue(JavaScriptMapConstant.DART_CLASS);
       enqueue(JavaScriptMapConstant.DART_PROTO_CLASS);
       enqueue(JavaScriptMapConstant.DART_STRING_CLASS);
       enqueue(JavaScriptMapConstant.DART_GENERAL_CLASS);
     } else {
-      registry.registerInstantiatedType(type);
+      registry.registerInstantiation(type);
     }
   }
 
   /// Called when resolving the `Symbol` constructor.
   void onSymbolConstructor(Registry registry) {
     assert(registry.isForResolution);
     // Make sure that _internals.Symbol.validated is registered.
     assert(backend.compiler.symbolValidatedConstructor != null);
     registerBackendStaticInvocation(
         backend.compiler.symbolValidatedConstructor, registry);
@@ skipping 23 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }