Revert "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 1402 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) {
+  void registerRequiredType(DartType type, Element enclosingElement) {
     // 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.hasBeenProcessed(constructor)) {
+          if (resolution.hasBeenResolved(constructor)) {
             reflectableMembers.add(constructor);
           }
         });
         // 3) all members, including fields via getter/setters (if resolved)
         cls.forEachClassMember((Member member) {
-          if (resolution.hasBeenProcessed(member.element)) {
+          if (resolution.hasBeenResolved(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.hasBeenProcessed(member.element)));
-                if (resolution.hasBeenProcessed(member.element)) {
+                //    resolution.hasBeenResolved(member.element)));
+                if (resolution.hasBeenResolved(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.hasBeenProcessed(element)) return;
+          if (!resolution.hasBeenResolved(element)) return;
           if (referencedFromMirrorSystem(element, false)) {
             reflectableMembers.add(element);
           }
         });
         cls.forEachClassMember((Member member) {
-          if (!resolution.hasBeenProcessed(member.element)) return;
+          if (!resolution.hasBeenResolved(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.hasBeenProcessed(member) &&
+            resolution.hasBeenResolved(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) reporter.log('Preserving names.');
 
     if (mustRetainMetadata) {
       reporter.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) {
-      _registerAsync(enqueuer, registry);
+      enqueue(enqueuer, getAsyncHelper(), registry);
+      enqueue(enqueuer, getSyncCompleterConstructor(), registry);
+      enqueue(enqueuer, getStreamIteratorConstructor(), registry);
+      enqueue(enqueuer, getWrapBody(), registry);
     } else if (element.asyncMarker == AsyncMarker.SYNC_STAR) {
-      _registerSyncStar(enqueuer, registry);
+      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);
     } else if (element.asyncMarker == AsyncMarker.ASYNC_STAR) {
-      _registerAsyncStar(enqueuer, registry);
+      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);
     }
   }
 
-  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) {
       reporter.reportHintMessage(
@@ skipping 138 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(Registry registry,
+  void onMapLiteral(ResolutionRegistry 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.registerInstantiation(type);
+      registry.registerInstantiatedType(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);
 }