Remove ResolutionEnqueuer._applyFirstMemberUse

pkg/compiler/lib/src/enqueue.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 dart2js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
@@ skipping 201 matching lines @@
   void checkClass(ClassEntity cls) {
     _universe.processClassMembers(cls,
         (MemberEntity member, EnumSet<MemberUse> useSet) {
       if (useSet.isNotEmpty) {
         _reporter.internalError(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
   }
 
-  /// Callback for applying the first seen use of a [member].
-  void _applyFirstMemberUse(MemberElement member, EnumSet<MemberUse> useSet) {
-    ClassElement cls = member.enclosingClass;
-    if (member.isFunction) {
-      MemberElement function = member;
-      if (function.name == Identifiers.noSuchMethod_) {
-        _registerNoSuchMethod(function);
-      }
-      if (function.name == Identifiers.call && !cls.typeVariables.isEmpty) {
-        _registerCallMethodWithFreeTypeVariables(function);
-      }
-    }
-    _applyMemberUse(member, useSet);
-  }
-
   /// Callback for applying the use of a [member].
   void _applyMemberUse(Entity member, EnumSet<MemberUse> useSet) {
     if (useSet.contains(MemberUse.NORMAL)) {
       _addToWorkList(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE)) {
       _registerClosurizedMember(member);
     }
   }
 
   /// Callback for applying the use of a [cls].
   void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
     if (useSet.contains(ClassUse.INSTANTIATED)) {
       _recentClasses.add(cls);
-      _universe.processClassMembers(cls, _applyFirstMemberUse);
+      _universe.processClassMembers(cls, _applyMemberUse);
       // We only tell the backend once that [cls] was instantiated, so
       // any additional dependencies must be treated as global
       // dependencies.
       applyImpact(backend.registerInstantiatedClass(cls, forResolution: true));
     }
     if (useSet.contains(ClassUse.IMPLEMENTED)) {
       applyImpact(backend.registerImplementedClass(cls, forResolution: true));
     }
   }
 
@@ skipping 64 matching lines @@
   }
 
   void _registerIsCheck(DartType type) {
     type = _universe.registerIsCheck(type, _resolution);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
   }
 
-  void _registerCallMethodWithFreeTypeVariables(Element element) {
-    applyImpact(backend.registerCallMethodWithFreeTypeVariables(element,
-        forResolution: true));
-    _universe.callMethodsWithFreeTypeVariables.add(element);
-  }
-
   void _registerClosurizedMember(MemberElement element) {
     assert(element.isInstanceMember);
     if (element.type.containsTypeVariables) {
       applyImpact(backend.registerClosureWithFreeTypeVariables(element,
           forResolution: true));
       _universe.closuresWithFreeTypeVariables.add(element);
     }
     applyImpact(backend.registerBoundClosure());
     _universe.closurizedMembers.add(element);
   }
@@ skipping 58 matching lines @@
           element, "Resolution work list is closed. Trying to add $element.");
     }
 
     applyImpact(backend.registerUsedElement(element, forResolution: true));
     _openWorld.registerUsedElement(element);
 
     ResolutionWorkItem workItem = _resolution.createWorkItem(element);
     _queue.add(workItem);
   }
 
-  void _registerNoSuchMethod(Element element) {
-    backend.registerNoSuchMethod(element);
-  }
-
   /// Adds an action to the deferred task queue.
   /// The action is performed the next time the resolution queue has been
   /// emptied.
   ///
   /// The queue is processed in FIFO order.
   void addDeferredAction(Entity entity, void action()) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           entity,
           "Resolution work list is closed. "
@@ skipping 119 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }