Move codegen registration to transformImpact method.

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 612 matching lines @@
   LookupMapAnalysis lookupMapAnalysis;
 
   /// Codegen support for typed JavaScript interop.
   JsInteropAnalysis jsInteropAnalysis;
 
   /// Support for classifying `noSuchMethod` implementations.
   NoSuchMethodRegistry noSuchMethodRegistry;
 
   JavaScriptConstantTask constantCompilerTask;
 
-  JavaScriptResolutionCallbacks resolutionCallbacks;
+  JavaScriptImpactTransformer impactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
 
   final SourceInformationStrategy sourceInformationStrategy;
 
   final BackendHelpers helpers;
   final BackendImpacts impacts;
 
@@ skipping 18 matching lines @@
         super(compiler) {
     emitter = new CodeEmitterTask(
         compiler, namer, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     jsInteropAnalysis = new JsInteropAnalysis(this);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
-    resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
+    impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.useCpsIr
          ? new CpsFunctionCompiler(
              compiler, this, sourceInformationStrategy)
          : new SsaFunctionCompiler(this, sourceInformationStrategy);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
@@ skipping 759 matching lines @@
       Enqueuer enqueuer,
       Registry registry) {
     if (enqueuer.isResolutionQueue || methodNeedsRti(closure)) {
       registerComputeSignature(enqueuer, registry);
     }
     super.registerClosureWithFreeTypeVariables(closure, enqueuer, registry);
   }
 
   /// Call during codegen if an instance of [closure] is being created.
   void registerInstantiatedClosure(LocalFunctionElement closure,
-                                   CodegenRegistry registry) {
+                                   Registry registry) {
     if (methodNeedsRti(closure)) {
       registerComputeSignature(compiler.enqueuer.codegen, registry);
     }
   }
 
   void registerBoundClosure(Enqueuer enqueuer) {
     boundClosureClass.ensureResolved(resolution);
     registerInstantiatedType(
         boundClosureClass.rawType,
         enqueuer,
@@ skipping 242 matching lines @@
     for (BackendImpact otherImpact in impact.otherImpacts) {
       enqueueImpact(enqueuer, otherImpact, registry);
     }
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
       generatedCode[element] = jsAst.js(
           "function () { throw new Error('Compile time error in $element') }");
-      return const WorldImpact();
+      return const CodegenImpact();
     }
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) {
       return const WorldImpact();
     }
     if (element.isConstructor && element.enclosingClass == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
-      return const WorldImpact();
+      return const CodegenImpact();
     }
     if (kind.category == ElementCategory.VARIABLE) {
       ConstantValue initialValue =
           constants.getConstantValueForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue, work.registry);
         addCompileTimeConstantForEmission(initialValue);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) {
-          return const WorldImpact();
+          return impactTransformer.transformCodegenImpact(
+              work.registry.worldImpact);
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         compiler.enqueuer.codegen.registerStaticUse(
             helpers.cyclicThrowHelper);
       }
     }
 
     generatedCode[element] = functionCompiler.compile(work);
-    return const WorldImpact();
+    return impactTransformer.transformCodegenImpact(work.registry.worldImpact);
   }
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
@@ skipping 884 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) {
-        for (Dependency dependency in metadataConstants) {
-          registerCompileTimeConstant(
-              dependency.constant,
-              new EagerRegistry(compiler,
-                  dependency.annotatedElement.analyzableElement.treeElements));
-        }
-      } else {
-        for (Dependency dependency in metadataConstants) {
-          registerCompileTimeConstant(
-              dependency.constant,
-              new CodegenRegistry(compiler,
-                  dependency.annotatedElement.analyzableElement.treeElements));
-        }
+      for (Dependency dependency in metadataConstants) {
+        registerCompileTimeConstant(
+            dependency.constant,
+            new EagerRegistry('EagerRegistry for ${dependency}', enqueuer));
+      }
+      if (!enqueuer.isResolutionQueue) {
         metadataConstants.clear();
       }
     }
     return true;
   }
 
   void onQueueClosed() {
     lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
@@ skipping 297 matching lines @@
           if (constructedConstant.type.element == annotationClass) {
             return true;
           }
         }
       }
       return false;
     });
   }
 }
 
-class JavaScriptResolutionCallbacks extends ResolutionCallbacks {
+class JavaScriptImpactTransformer extends ImpactTransformer {
   final JavaScriptBackend backend;
 
-  JavaScriptResolutionCallbacks(this.backend);
+  JavaScriptImpactTransformer(this.backend);
 
   BackendImpacts get impacts => backend.impacts;
 
-  WorldImpact transformImpact(ResolutionImpact worldImpact) {
+  @override
+  WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
     for (Feature feature in worldImpact.features) {
       switch (feature) {
         case Feature.ABSTRACT_CLASS_INSTANTIATION:
           registerBackendImpact(
               transformed, impacts.abstractClassInstantiation);
           break;
         case Feature.ASSERT:
           registerBackendImpact(transformed, impacts.assertWithoutMessage);
@@ skipping 202 matching lines @@
         }
       }
     }
     if (type is FunctionType) {
       registerBackendImpact(transformed, impacts.functionTypeCheck);
     }
     if (type.element != null && backend.isNative(type.element)) {
       registerBackendImpact(transformed, impacts.nativeTypeCheck);
     }
   }
+
+  @override
+  WorldImpact transformCodegenImpact(CodegenImpact impact) {
+    EagerRegistry registry = impact.registry;
+    Enqueuer world = registry.world;
+
+    for (InterfaceType type in impact.instantiatedTypes) {
+      backend.registerInstantiatedType(type, world, registry);
+    }
+
+    for (Element element in impact.staticUses) {
+      world.registerStaticUse(element);
+    }
+
+    for (UniverseSelector selector in impact.dynamicInvocations) {
+      world.registerDynamicInvocation(selector);
+    }
+
+    for (UniverseSelector selector in impact.dynamicGetters) {
+      world.registerDynamicGetter(selector);
+    }
+
+    for (UniverseSelector selector in impact.dynamicSetters) {
+      world.registerDynamicSetter(selector);
+    }
+
+    for (UniverseSelector selector in impact.dynamicSetters) {
+      world.registerDynamicSetter(selector);
+    }
+
+    for (Element element in impact.getterForSuperElements) {
+      world.registerGetterForSuperMethod(element);
+    }
+
+    for (Element element in impact.fieldGetters) {
+      world.registerFieldGetter(element);
+    }
+
+    for (Element element in impact.fieldSetters) {
+      world.registerFieldSetter(element);
+    }
+
+    for (DartType type in impact.isChecks) {
+      world.registerIsCheck(type);
+      backend.registerIsCheckForCodegen(type, world, registry);
+    }
+
+    for (ConstantValue constant in impact.compileTimeConstants) {
+      backend.registerCompileTimeConstant(constant, registry);
+      backend.addCompileTimeConstantForEmission(constant);
+    }
+
+    for (Pair<DartType, DartType> check in
+            impact.typeVariableBoundsSubtypeChecks) {
+      backend.registerTypeVariableBoundsSubtypeCheck(check.a, check.b);
+    }
+
+    for (LocalFunctionElement element in impact.closures) {
+      backend.registerInstantiatedClosure(element, registry);
+    }
+
+    for (Element element in impact.closurizedFunctions) {
+      world.registerGetOfStaticFunction(element);
+    }
+
+    for (String name in impact.constSymbols) {
+      backend.registerConstSymbol(name);
+    }
+
+    for (Set<ClassElement> classes in impact.specializedGetInterceptors) {
+      backend.registerSpecializedGetInterceptor(classes);
+    }
+
+    if (impact.usesInterceptor) {
+      backend.registerUseInterceptor(world);
+    }
+
+    for (ClassElement element in impact.typeConstants) {
+      backend.customElementsAnalysis.registerTypeConstant(element, world);
+      backend.lookupMapAnalysis.registerTypeConstant(element);
+    }
+
+    for (FunctionElement element in impact.asyncMarkers) {
+      backend.registerAsyncMarker(element, world, registry);
+    }
+
+    // TODO(johnniwinther): Remove eager registration.
+    return const WorldImpact();
+  }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }