Get rid of the name in HInvokeDynamic (just use the selector instead).

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 1385 matching lines @@
   js.Call jsPropertyCall(js.Expression receiver,
                          String fieldName,
                          List<js.Expression> arguments) {
     return new js.Call(new js.PropertyAccess.field(receiver, fieldName),
                        arguments);
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
+    SourceString name = node.selector.name;
     String methodName;
     List<js.Expression> arguments;
 
     // Avoid adding the generative constructor name to the list of
     // seen selectors.
     if (node.inputs[0] is HForeignNew) {
       // TODO(ahe): The constructor name was statically resolved in
       // SsaBuilder.buildFactory. Is there a cleaner way to do this?
-      methodName = node.name.slowToString();
+      methodName = name.slowToString();
       arguments = visitArguments(node.inputs);
     } else {
       methodName = compiler.namer.instanceMethodInvocationName(
-          currentLibrary, node.name, node.selector);
+          node.selector.library, name, node.selector);
       arguments = visitArguments(node.inputs);
       bool inLoop = node.block.enclosingLoopHeader !== null;
 
       // Register this invocation to collect the types used at all call sites.
       Selector selector = getOptimizedSelectorFor(node, node.selector);
       backend.registerDynamicInvocation(node, selector, types);
 
       // 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.
       Element target = node.element;
       if (target === null || target.isGetter()) {
         // TODO(kasperl): If we have a typed selector for the call, we
         // may know something about the types of closures that need
         // the specific closure call method.
         Selector call = new Selector.callClosureFrom(selector);
         world.registerDynamicInvocation(call.name, call);
       }
 
       if (target !== null) {
         // If we know we're calling a specific method, register that
         // method only.
         if (inLoop) backend.builder.functionsCalledInLoop.add(target);
         world.registerDynamicInvocationOf(target);
       } else {
-        if (inLoop) backend.builder.selectorsCalledInLoop[node.name] = selector;
-        world.registerDynamicInvocation(node.name, selector);
+        if (inLoop) backend.builder.selectorsCalledInLoop[name] = selector;
+        world.registerDynamicInvocation(name, selector);
       }
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
     // TODO(4434): For private members we need to use the untyped selector.
-    if (node.name.isPrivate()) return defaultSelector;
+    if (defaultSelector.name.isPrivate()) return defaultSelector;
     HType receiverHType = types[node.inputs[0]];
     Type receiverType = receiverHType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
-    push(jsPropertyCall(pop(),
-                        compiler.namer.setterName(currentLibrary, node.name),
-                        visitArguments(node.inputs)),
-         node);
-    Selector setter = new Selector.setter(node.name, currentLibrary);
+    Selector setter = node.selector;
+    String name = compiler.namer.setterName(setter.library, setter.name);
+    push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicSetter(
-        node.name, getOptimizedSelectorFor(node, setter));
+        setter.name, getOptimizedSelectorFor(node, setter));
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
-    push(jsPropertyCall(pop(),
-                        compiler.namer.getterName(currentLibrary, node.name),
-                        visitArguments(node.inputs)),
-         node);
-    Selector getter = new Selector.getter(node.name, currentLibrary);
+    Selector getter = node.selector;
+    String name = compiler.namer.getterName(getter.library, getter.name);
+    push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicGetter(
-        node.name, getOptimizedSelectorFor(node, getter));
+        getter.name, getOptimizedSelectorFor(node, getter));
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         compiler.namer.closureInvocationName(node.selector),
                         visitArguments(node.inputs)),
          node);
     Selector call = new Selector.callClosureFrom(node.selector);
     world.registerDynamicInvocation(call.name, call);
@@ skipping 1415 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }