Make selector registration in the resolver and code generator more explicit.

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 1392 matching lines @@
     } else {
       methodName = compiler.namer.instanceMethodInvocationName(
           currentLibrary, node.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);
 
-      if (node.element !== null) {
+      // 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(node.element);
-        world.registerDynamicInvocationOf(node.element);
+        if (inLoop) backend.builder.functionsCalledInLoop.add(target);
+        world.registerDynamicInvocationOf(target);
       } else {
         if (inLoop) backend.builder.selectorsCalledInLoop[node.name] = selector;
         world.registerDynamicInvocation(node.name, selector);
       }
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
@@ skipping 28 matching lines @@
     world.registerDynamicGetter(
         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.

[floitsch, 2012/08/15 14:14:04]

remove comment.

[kasperl, 2012/08/16 10:35:47]

Done.

-    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,
-                                    call);
+    Selector call = new Selector.callClosureFrom(node.selector);
+    world.registerDynamicInvocation(call.name, 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 1376 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }