Support named arguments for statically resolved calls.

frog/leg/resolver.dart

 // Copyright (c) 2011, 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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 573 matching lines @@
     ClassElement cls = resolveTypeRequired(node);
     if (cls.name == const SourceString('String') ||
         cls.name == const SourceString('List') ||
         cls.name == const SourceString('int') ||
         cls.name == const SourceString('num') ||
         cls.name == const SourceString('double')) {
       cancel(node, "type test for ${cls.name} is not implemented");
     }
   }
 
+  void handleArguments(Send node) {
+    int count = 0;
+    List<SourceString> namedArguments = <SourceString>[];
+    for (Link<Node> link = node.argumentsNode.nodes;
+         !link.isEmpty();
+         link = link.tail) {
+      count++;
+      Expression argument = link.head;
+      visit(argument);
+      if (argument.asNamedArgument() != null) {
+        NamedArgument named = argument;
+        namedArguments.add(named.name.source);
+      }
+    }
+    mapping.setSelector(node, new Invocation(count, namedArguments));
+  }
+
   visitSend(Send node) {
     Element target = resolveSend(node);
     if (node.isOperator) {
       if (node.selector.asIdentifier().source.stringValue === 'is') {
         resolveTypeTest(node.arguments.head);
         assert(node.arguments.tail.isEmpty());
         mapping.setSelector(node, Selector.BINARY_OPERATOR);
       } else if (node.arguments.isEmpty()) {
         mapping.setSelector(node, Selector.UNARY_OPERATOR);
       } else {
         visit(node.argumentsNode);
         mapping.setSelector(node, Selector.BINARY_OPERATOR);
       }
     } else if (node.isIndex) {
       visit(node.argumentsNode);
       assert(node.arguments.tail.isEmpty());
       mapping.setSelector(node, Selector.INDEX);
     } else if (node.isPropertyAccess) {
       mapping.setSelector(node, Selector.GETTER);
     } else {
-      int count = 0;
-      List<SourceString> namedArguments = <SourceString>[];
-      for (Link<Node> link = node.argumentsNode.nodes;
-           !link.isEmpty();
-           link = link.tail) {
-        count++;
-        Expression argument = link.head;
-        visit(argument);
-        if (argument.asNamedArgument() != null) {
-          NamedArgument named = argument;
-          namedArguments.add(named.name.source);
-        }
-      }
-      mapping.setSelector(node, new Invocation(count, namedArguments));
+      handleArguments(node);
     }
     // TODO(ngeoffray): If target is a field, check that there's a
     // getter.
     return useElement(node, target);
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     visit(node.argumentsNode);
     // TODO(ngeoffray): If target is a field, check that there's a
@@ skipping 74 matching lines @@
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     if (node.isConst()) cancel(node, 'const expressions are not implemented');
     if (node.send.selector.asTypeAnnotation() === null) {
       cancel(
           node, 'named constructors with type arguments are not implemented');
     }
 
-    visit(node.send.argumentsNode);
-
     SourceString constructorName;
     Node typeName = node.send.selector.asTypeAnnotation().typeName;
     if (typeName.asSend() !== null) {
       Identifier receiver = typeName.asSend().receiver.asIdentifier();
       Identifier selector = typeName.asSend().selector.asIdentifier();
       SourceString className = receiver.source;
       SourceString name = selector.source;
       constructorName = Elements.constructConstructorName(className, name);
     } else {
       constructorName = typeName.asIdentifier().source;
@@ skipping 15 matching lines @@
         if (node.send.argumentCount() != function.parameterCount(compiler)) {
           // TODO(ngeoffray): reslution error with wrong number of
           // parameters. We cannot do this rigth now because of the
           // List constructor.
         }
       }
     } else {
       Node selector = node.send.selector;
       error(selector, MessageKind.CANNOT_RESOLVE_TYPE, [selector]);
     }
+    handleArguments(node.send);
     useElement(node.send, constructor);
     return null;
   }
 
   ClassElement resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     ClassElement cls = visit(node);
     typeRequired = old;
     return cls;
@@ skipping 353 matching lines @@
 class TopScope extends Scope {
   Universe universe;
 
   TopScope(Universe this.universe) : super(null, null);
   Element lookup(SourceString name) => universe.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }