Stop passing the selector name separately to methods in the enqueuer.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 2065 matching lines @@
       target = currentClass.lookupSuperSelector(selector, compiler);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
         target = warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] which calls
         // [JSInvocationMirror._invokeOn].
-        world.registerDynamicInvocation(selector.name, selector);
+        world.registerDynamicInvocation(selector);
         compiler.backend.registerSuperNoSuchMethod(mapping);
       }
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.isClass()) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
@@ skipping 210 matching lines @@
 
     if (node.isCall) {
       if (Elements.isUnresolved(target) ||
           target.isGetter() ||
           target.isField() ||
           Elements.isClosureSend(node, target)) {
         // If we don't know what we're calling or if we are calling a getter,
         // we need to register that fact that we may be calling a closure
         // with the same arguments.
         Selector call = new Selector.callClosureFrom(selector);
-        world.registerDynamicInvocation(call.name, call);
+        world.registerDynamicInvocation(call);
       } else if (target.impliesType()) {
         // We call 'call()' on a Type instance returned from the reference to a
         // class or typedef literal. We do not need to register this call as a
         // dynamic invocation, because we statically know what the target is.
       } else if (!selector.applies(target, compiler)) {
         warnArgumentMismatch(node, target);
       }
 
       if (target != null &&
           target.isForeign(compiler) &&
@@ skipping 89 matching lines @@
               {'className': currentClass, 'memberName': selector.name});
           compiler.backend.registerSuperNoSuchMethod(mapping);
         }
       }
       useElement(node.selector, getter);
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(SourceString name) {
         Selector binop = new Selector.binaryOperator(name);
-        world.registerDynamicInvocation(binop.name, binop);
+        world.registerDynamicInvocation(binop);
         mapping.setOperatorSelectorInComplexSendSet(node, binop);
       }
       if (identical(source, '++')) {
         registerBinaryOperator(const SourceString('+'));
       } else if (identical(source, '--')) {
         registerBinaryOperator(const SourceString('-'));
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return useElement(node, setter);
   }
 
   void registerSend(Selector selector, Element target) {
     if (target == null || target.isInstanceMember()) {
       if (selector.isGetter()) {
-        world.registerDynamicGetter(selector.name, selector);
+        world.registerDynamicGetter(selector);
       } else if (selector.isSetter()) {
-        world.registerDynamicSetter(selector.name, selector);
+        world.registerDynamicSetter(selector);
       } else {
-        world.registerDynamicInvocation(selector.name, selector);
+        world.registerDynamicInvocation(selector);
       }
     } else if (Elements.isStaticOrTopLevel(target)) {
       // TODO(kasperl): It seems like we're not supposed to register
       // the use of classes. Wouldn't it be simpler if we just did?
       if (!target.isClass()) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         world.registerStaticUse(target.declaration);
       }
     }
@@ skipping 362 matching lines @@
         error(node.target, MessageKind.INVALID_CONTINUE);
       }
       label.setContinueTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   registerImplicitInvocation(SourceString name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
-    world.registerDynamicInvocation(name, selector);
+    world.registerDynamicInvocation(selector);
   }
 
   visitForIn(ForIn node) {
     LibraryElement library = enclosingElement.getLibrary();
     mapping.setIteratorSelector(node, compiler.iteratorSelector);
-    world.registerDynamicGetter(compiler.iteratorSelector.name,
-                                compiler.iteratorSelector);
+    world.registerDynamicGetter(compiler.iteratorSelector);
     mapping.setCurrentSelector(node, compiler.currentSelector);
-    world.registerDynamicGetter(compiler.currentSelector.name,
-                                compiler.currentSelector);
+    world.registerDynamicGetter(compiler.currentSelector);
     mapping.setMoveNextSelector(node, compiler.moveNextSelector);
-    world.registerDynamicInvocation(compiler.moveNextSelector.name,
-                                    compiler.moveNextSelector);
+    world.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
     Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, blockScope);
 
     Send send = declaration.asSend();
     VariableDefinitions variableDefinitions =
         declaration.asVariableDefinitions();
     Element loopVariable;
@@ skipping 1197 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }