Remove ResolutionEnqueuer._applyFirstMemberUse

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 1373 matching lines @@
   }
 
   WorldImpact registerGetOfStaticFunction() {
     return impactTransformer.createImpactFor(impacts.staticClosure);
   }
 
   WorldImpact _registerComputeSignature() {
     return impactTransformer.createImpactFor(impacts.computeSignature);
   }
 
+  /// Called to register that the `runtimeType` property has been accessed. Any
+  /// backend specific [WorldImpact] of this is returned.
   WorldImpact registerRuntimeType() {
     return impactTransformer.createImpactFor(impacts.runtimeTypeSupport);
   }
 
   void registerTypeVariableBoundsSubtypeCheck(
       DartType typeArgument, DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
   WorldImpact computeDeferredLoadingImpact() {
     return impactTransformer.createImpactFor(impacts.deferredLoading);
   }
 
-  void registerNoSuchMethod(FunctionElement noSuchMethod) {
+  /// Called to register a `noSuchMethod` implementation.
+  void registerNoSuchMethod(MethodElement noSuchMethod) {
     noSuchMethodRegistry.registerNoSuchMethod(noSuchMethod);
   }
 
   /// Called when resolving a call to a foreign function.
   native.NativeBehavior resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
     native.NativeResolutionEnqueuer nativeEnqueuer =
         compiler.enqueuer.resolution.nativeEnqueuer;
     if (element.name == BackendHelpers.JS) {
       return nativeEnqueuer.resolveJsCall(node, resolver);
@@ skipping 425 matching lines @@
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     } else if (element == helpers.invokeOnMethod && forResolution) {
       hasInvokeOnSupport = true;
     }
     customElementsAnalysis.registerStaticUse(element,
         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 451 matching lines @@
     // 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);
+      }
+    }
     noSuchMethodRegistry.onQueueEmpty();
     if (!enabledNoSuchMethod &&
         (noSuchMethodRegistry.hasThrowingNoSuchMethod ||
             noSuchMethodRegistry.hasComplexNoSuchMethod)) {
       enqueuer.applyImpact(enableNoSuchMethod());
       enabledNoSuchMethod = true;
     }
 
     if (compiler.options.useKernel && compiler.mainApp != null) {
       kernelTask.buildKernelIr();
@@ skipping 944 matching lines @@
   ClassElement get mapImplementation => helpers.mapLiteralClass;
   ClassElement get constMapImplementation => helpers.constMapLiteralClass;
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
   ClassElement get functionImplementation => helpers.coreClasses.functionClass;
 }