Add name and library to selectors.

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 1402 matching lines @@
         if (inLoop) backend.builder.functionsCalledInLoop.add(node.element);
         world.registerDynamicInvocationOf(node.element);
       } else {
         if (inLoop) backend.builder.selectorsCalledInLoop[node.name] = selector;
         world.registerDynamicInvocation(node.name, selector);
       }
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
-  Selector getOptimizedSelectorFor(HInvoke node, Selector defaultSelector) {
+  Selector getOptimizedSelectorFor(HInvokeDynamic node,
+                                   Selector defaultSelector) {
     // TODO(4434): For private members we need to use the untyped selector.
     if (node.name.isPrivate()) return defaultSelector;
     Type receiverType = node.inputs[0].propagatedType.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);
     world.registerDynamicSetter(
-        node.name, getOptimizedSelectorFor(node, Selector.SETTER));
+        node.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);
     world.registerDynamicGetter(
-        node.name, getOptimizedSelectorFor(node, Selector.GETTER));
+        node.name, getOptimizedSelectorFor(node, getter));
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         compiler.namer.closureInvocationName(node.selector),
                         visitArguments(node.inputs)),
          node);
     // TODO(floitsch): we should have a separate list for closure invocations.
+    Selector call = new Selector.call(
+        compiler.namer.CLOSURE_INVOCATION_NAME,
+        node.selector.library,
+        node.selector.argumentCount,
+        node.selector.namedArguments);
     world.registerDynamicInvocation(compiler.namer.CLOSURE_INVOCATION_NAME,
-                                    node.selector);
+                                    call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     use(node.target);
     push(new js.Call(pop(), visitArguments(node.inputs)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     Element superClass = superMethod.getEnclosingClass();
@@ skipping 37 matching lines @@
 
   visitFieldGet(HFieldGet node) {
     String name =
         compiler.namer.instanceFieldName(node.library, node.fieldName);
     use(node.receiver);
     push(new js.PropertyAccess.field(pop(), name), node);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field getter.
       // This might lead to unnecessary getters, but these cases should be
       // rare.
-      world.registerDynamicGetter(node.fieldName, Selector.GETTER);
+      Selector getter = new Selector.getter(node.fieldName, node.library);
+      world.registerDynamicGetter(node.fieldName, getter);
     } else {
       Type type = node.receiver.propagatedType.computeType(compiler);
       if (type != null) {
-        world.registerFieldGetter(node.element.name, type);
+        world.registerFieldGetter(node.element.name, node.library, type);
       }
     }
   }
 
   // Determine if an instruction is a simple number computation
   // involving only things with guaranteed number types and a given
   // field.
   bool isSimpleFieldNumberComputation(HInstruction value, HFieldSet node) {
     if (value.guaranteedType.union(HType.NUMBER) == HType.NUMBER) return true;
     if (value is HBinaryArithmetic) {
@@ skipping 12 matching lines @@
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
     String name =
         compiler.namer.instanceFieldName(node.library, node.fieldName);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field setter.
       // This might lead to unnecessary setters, but these cases should be
       // rare.
-      world.registerDynamicSetter(node.fieldName, Selector.SETTER);
+      Selector setter = new Selector.setter(node.fieldName, node.library);
+      world.registerDynamicSetter(node.fieldName, setter);
     } else {
       Type type = node.receiver.propagatedType.computeType(compiler);
       if (type != null) {
         if (!work.element.isGenerativeConstructorBody()) {
-          world.registerFieldSetter(node.element.name, type);
+          world.registerFieldSetter(node.element.name, node.library, type);
         }
         // Determine the types seen so far for the field. If only number
         // types have been seen and the value of the field set is a
         // simple number computation only depending on that field, we
         // can safely keep the number type for the field.
         HType fieldSettersType = backend.fieldSettersTypeSoFar(node.element);
         HType initializersType =
             backend.typeFromInitializersSoFar(node.element);
         HType fieldType = fieldSettersType.union(initializersType);
         if (HType.NUMBER.union(fieldType) == HType.NUMBER &&
@@ skipping 1274 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }