Move class/member computation from CodegenEnqueuer to CodegenWorldBuilder.

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.
 
 library js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 523 matching lines @@
   /// Builds kernel representation for the program.
   KernelTask kernelTask;
 
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptImpactTransformer impactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
+  bool _noSuchMethodEnabledForCodegen = false;
 
   SourceInformationStrategy sourceInformationStrategy;
 
   JavaScriptBackendSerialization serialization;
 
   StagedWorldImpactBuilder constantImpactsForResolution =
       new StagedWorldImpactBuilder();
 
   StagedWorldImpactBuilder constantImpactsForCodegen =
       new StagedWorldImpactBuilder();
@@ skipping 745 matching lines @@
     rti.computeClassesNeedingRti(
         compiler.enqueuer.resolution.universe, closedWorld);
     _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
+  /// Called to register that an instantiated generic class has a call method.
+  /// Any backend specific [WorldImpact] of this is returned.
+  ///
+  /// Note: The [callMethod] is registered even thought it doesn't reference
+  /// the type variables.
   WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod,
       {bool forResolution}) {
     if (forResolution || methodNeedsRti(callMethod)) {
       return _registerComputeSignature();
     }
     return const WorldImpact();
   }
 
   WorldImpact registerClosureWithFreeTypeVariables(Element closure,
       {bool forResolution}) {
@@ skipping 62 matching lines @@
           }
         }
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
-  WorldImpact enableNoSuchMethod() {
+  WorldImpact computeNoSuchMethodImpact() {
     return impactTransformer.createImpactFor(impacts.noSuchMethodSupport);
   }
 
   WorldImpact enableIsolateSupport({bool forResolution}) {
     WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     // TODO(floitsch): We should also ensure that the class IsolateMessage is
     // instantiated. Currently, just enabling isolate support works.
     if (compiler.mainFunction != null) {
       // The JavaScript backend implements [Isolate.spawn] by looking up
       // top-level functions by name. So all top-level function tear-off
@@ skipping 378 matching lines @@
         }
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     } else if (element == helpers.invokeOnMethod && forResolution) {
       hasInvokeOnSupport = true;
     }
     customElementsAnalysis.registerStaticUse(element,
         forResolution: forResolution);
 
+    if (element.isFunction && element.isInstanceMember) {
+      MemberElement function = element;
+      ClassElement cls = function.enclosingClass;
+      if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
+        worldImpact.addImpact(registerCallMethodWithFreeTypeVariables(function,
+            forResolution: forResolution));
+      }
+    }
     if (forResolution) {
-      if (element.isFunction && element.isInstanceMember) {
-        MemberElement function = element;
-        ClassElement cls = function.enclosingClass;
-        if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
-          worldImpact.addImpact(registerCallMethodWithFreeTypeVariables(
-              function,
-              forResolution: true));
-        }
-      }
       // Enable isolate support if we start using something from the isolate
       // library, or timers for the async library.  We exclude constant fields,
       // which are ending here because their initializing expression is
       // compiled.
       LibraryElement library = element.library;
       if (!hasIsolateSupport && !(element.isField && element.isConst)) {
         Uri uri = library.canonicalUri;
         if (uri == Uris.dart_isolate) {
           hasIsolateSupport = true;
           worldImpact
@@ skipping 14 matching lines @@
         // Enable runtime type support if we discover a getter called
         // runtimeType. We have to enable runtime type before hitting the
         // codegen, so that constructors know whether they need to generate code
         // for runtime type.
         hasRuntimeTypeSupport = true;
         // TODO(ahe): Record precise dependency here.
         worldImpact.addImpact(registerRuntimeType());
       } else if (compiler.commonElements.isFunctionApplyMethod(element)) {
         hasFunctionApplySupport = true;
       }
+    } else {
+      // TODO(sigmund): add other missing dependencies (internals, selectors
+      // enqueued after allocations).
+      compiler.dumpInfoTask.registerDependency(element);
     }
     return worldImpact;
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
@@ skipping 386 matching lines @@
     //
     // Return early if any elements are added to avoid counting the elements as
     // due to mirrors.
     enqueuer.applyImpact(customElementsAnalysis.flush(
         forResolution: enqueuer.isResolutionQueue));
     enqueuer.applyImpact(
         lookupMapAnalysis.flush(forResolution: enqueuer.isResolutionQueue));
     enqueuer.applyImpact(
         typeVariableHandler.flush(forResolution: enqueuer.isResolutionQueue));
 
-    if (!enqueuer.queueIsEmpty) return false;
-
-    for (ClassElement cls in recentClasses) {
-      Element element = cls.lookupLocalMember(Identifiers.noSuchMethod_);
-      if (element != null && element.isInstanceMember && element.isFunction) {
-        registerNoSuchMethod(element);
+    if (enqueuer.isResolutionQueue) {
+      for (ClassElement cls in recentClasses) {
+        Element element = cls.lookupLocalMember(Identifiers.noSuchMethod_);
+        if (element != null && element.isInstanceMember && element.isFunction) {
+          registerNoSuchMethod(element);
+        }
       }
     }
     noSuchMethodRegistry.onQueueEmpty();
-    if (!enabledNoSuchMethod &&
-        (noSuchMethodRegistry.hasThrowingNoSuchMethod ||
-            noSuchMethodRegistry.hasComplexNoSuchMethod)) {
-      enqueuer.applyImpact(enableNoSuchMethod());
-      enabledNoSuchMethod = true;
+    if (enqueuer.isResolutionQueue) {
+      if (!enabledNoSuchMethod &&
+          (noSuchMethodRegistry.hasThrowingNoSuchMethod ||
+              noSuchMethodRegistry.hasComplexNoSuchMethod)) {
+        enqueuer.applyImpact(computeNoSuchMethodImpact());
+        enabledNoSuchMethod = true;
+      }
+    } else {
+      if (enabledNoSuchMethod && !_noSuchMethodEnabledForCodegen) {
+        enqueuer.applyImpact(computeNoSuchMethodImpact());
+        _noSuchMethodEnabledForCodegen = true;
+      }
     }
 
+    if (!enqueuer.queueIsEmpty) return false;
+
     if (compiler.options.useKernel && compiler.mainApp != null) {
       kernelTask.buildKernelIr();
     }
 
     if (compiler.options.hasIncrementalSupport &&
         !hasIncrementalTearOffSupport) {
       // Always enable tear-off closures during incremental compilation.
       Element element = helpers.closureFromTearOff;
       if (element != null) {
         enqueuer.applyImpact(
@@ skipping 980 matching lines @@
   @override
   bool isInterceptorClass(ClassElement cls) {
     return helpers.backend.isInterceptorClass(cls);
   }
 
   @override
   bool isNative(Element element) {
     return helpers.backend.isNative(element);
   }
 }