Do not infer types of arguments of closures and methods named "call".

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 1061 matching lines @@
     }
     return lookupTarget;
   }
 
   Element resolveSuperOrThisForSend(FunctionElement constructor,
                                     FunctionExpression functionNode,
                                     Send call) {
     // Resolve the selector and the arguments.
     ResolverTask resolver = visitor.compiler.resolver;
     visitor.inStaticContext(() {
-      visitor.resolveSelector(call);
+      visitor.resolveSelector(call, null);
       visitor.resolveArguments(call.argumentsNode);
     });
     Selector selector = visitor.mapping.getSelector(call);
     bool isSuperCall = Initializers.isSuperConstructorCall(call);
 
     ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
                                                            isSuperCall,
                                                            call);
     Selector constructorSelector =
         visitor.getRedirectingThisOrSuperConstructorSelector(call);
@@ skipping 897 matching lines @@
     visit(node.thenPart);
     visit(node.elsePart);
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (identical(str, '&&') || str == '||' || str == '!');
   }
 
   Element resolveSend(Send node) {
-    Selector selector = resolveSelector(node);
+    Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) mapping.superUses.add(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert()) {
         if (selector.argumentCount != 1) {
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
                 {'argumentCount': selector.argumentCount});
@@ skipping 102 matching lines @@
   DartType resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node == null) {
       // node is of the form !Type.
       node = argument.asSend().receiver.asTypeAnnotation();
       if (node == null) compiler.cancel("malformed send");
     }
     return resolveTypeRequired(node);
   }
 
-  static Selector computeSendSelector(Send node, LibraryElement library) {
+  static Selector computeSendSelector(Send node,
+                                      LibraryElement library,
+                                      Element element) {
     // First determine if this is part of an assignment.
     bool isSet = node.asSendSet() != null;
 
     if (node.isIndex) {
       return isSet ? new Selector.indexSet() : new Selector.index();
     }
 
     if (node.isOperator) {
       SourceString source = node.selector.asOperator().source;
       String string = source.stringValue;
@@ skipping 28 matching lines @@
         !link.isEmpty;
         link = link.tail) {
       Expression argument = link.head;
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         named.add(namedArgument.name.source);
       }
       arity++;
     }
 
+    if (element != null && element.isConstructor()) {

[ahe, 2013/04/29 10:07:41]

I don't understand what this is for.  Is this from a different CL?

[ngeoffray, 2013/04/29 10:12:09]

No, it's related to that CL. If I don't do that check, we're creating a closure
selector (line 2180), which is not correct.

+      return new Selector.callConstructor(
+          element.name, library, arity, named);
+    }
+
     // If we're invoking a closure, we do not have an identifier.
     return (identifier == null)
         ? new Selector.callClosure(arity, named)
         : new Selector.call(identifier.source, library, arity, named);
   }
 
-  Selector resolveSelector(Send node) {
+  Selector resolveSelector(Send node, Element element) {
     LibraryElement library = enclosingElement.getLibrary();
-    Selector selector = computeSendSelector(node, library);
+    Selector selector = computeSendSelector(node, library, element);
     if (selector != null) mapping.setSelector(node, selector);
     return selector;
   }
 
   void resolveArguments(NodeList list) {
     if (list == null) return;
     List<SourceString> seenNamedArguments = <SourceString>[];
     for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       visit(argument);
@@ skipping 360 matching lines @@
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
     if (!node.isConst() && isSymbolConstructor) {
       compiler.reportWarningCode(
           node.newToken, MessageKind.NON_CONST_BLOAT,
           {'name': compiler.symbolClass.name});
     }
-    resolveSelector(node.send);
+    resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
@@ skipping 1414 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }