Don't generate forwarding hooks if all noSuchMethod implementations

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.
 
 part of dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 144 matching lines @@
         // All field initializers must be resolved as they could
         // have an observable side-effect (and cannot be tree-shaken
         // away).
         addToWorkList(member);
         return;
       }
     } else if (member.kind == ElementKind.FUNCTION) {
       FunctionElement function = member;
       function.computeSignature(compiler);
       if (function.name == Compiler.NO_SUCH_METHOD) {
-        enableNoSuchMethod(function);
+        compiler.backend.registerNoSuchMethod(function, this);

[Johnni Winther, 2015/03/16 14:20:43]

Move this to the ResolutionEnqueuer; only resolution should analyze, while
codegen should take consequences, i.e. enqueue when needed.

[Harry Terkelsen, 2015/03/17 21:43:11]

I am calling Enqueuer.registerNoSuchMethod here because to me it looks like both
the ResolutionEnqueuer and CodegenEnqueuer need to enqueue the invocation mirror
code if there is a non-trivial nsm impl. In the case of ResolutionEnqueuer, it
will store all of the nsm impls and classify them onQueueEmpty and then set
enabledNoSuchMethod. In the case of the CodegenEnqueuer, it will enqueue the
invocation mirror code if the backend has enabledNoSuchMethod

       }
       if (function.name == Compiler.CALL_OPERATOR_NAME &&
           !cls.typeVariables.isEmpty) {
         registerCallMethodWithFreeTypeVariables(
             function, compiler.globalDependencies);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(function, compiler.world)) {
         registerClosurizedMember(function, compiler.globalDependencies);
@@ skipping 29 matching lines @@
         return;
       }
     }
 
     // The element is not yet used. Add it to the list of instance
     // members to still be processed.
     instanceMembersByName.putIfAbsent(memberName, () => new Set<Element>())
         .add(member);
   }
 
-  void enableNoSuchMethod(Element element) {}
   void enableIsolateSupport() {}
 
   void processInstantiatedClass(ClassElement cls) {
     task.measure(() {
       if (_processedClasses.contains(cls)) return;
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(compiler);
 
       void processClass(ClassElement cls) {
@@ skipping 508 matching lines @@
 
     nativeEnqueuer.registerElement(element);
     return true;
   }
 
   void enableIsolateSupport() {
     compiler.hasIsolateSupport = true;
     compiler.backend.enableIsolateSupport(this);
   }
 
-  void enableNoSuchMethod(Element element) {
-    if (compiler.enabledNoSuchMethod) return;
-    if (compiler.backend.isDefaultNoSuchMethodImplementation(element)) return;
-
-    compiler.enabledNoSuchMethod = true;
-    compiler.backend.enableNoSuchMethod(element, this);
-  }
-
   /**
    * 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(Element element, DeferredAction action) {
     if (queueIsClosed) {
@@ skipping 137 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }