Support named arguments for statically resolved calls.

frog/leg/universe.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.
 
 class Universe {
   final Element scope;
 
   Map<SourceString, Element> elements;
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
@@ skipping 46 matching lines @@
 
 class Selector implements Hashable {
   // The numbers of arguments of the selector. Includes named
   // arguments.
   final int argumentCount;
   final SelectorKind kind;
   const Selector(this.kind, this.argumentCount);
 
   int hashCode() => argumentCount + 1000 * namedArguments.length;
   List<SourceString> get namedArguments() => const <SourceString>[];
+  int get namedArgumentCount() => 0;
+  int get positionalArgumentCount() => argumentCount;
 
   static final Selector GETTER = const Selector(SelectorKind.GETTER, 0);
   static final Selector SETTER = const Selector(SelectorKind.SETTER, 1);
   static final Selector UNARY_OPERATOR =
       const Selector(SelectorKind.OPERATOR, 0);
   static final Selector BINARY_OPERATOR =
       const Selector(SelectorKind.OPERATOR, 1);
   static final Selector INDEX = const Selector(SelectorKind.INDEX, 1);
   static final Selector INDEX_SET = const Selector(SelectorKind.INDEX, 2);
   static final Selector INDEX_AND_INDEX_SET =
       const Selector(SelectorKind.INDEX, 2);
   static final Selector GETTER_AND_SETTER =
       const Selector(SelectorKind.SETTER, 1);
   static final Selector INVOCATION_0 = const Invocation(0);
 
   bool applies(Compiler compiler, FunctionElement element) {
     FunctionParameters parameters = element.computeParameters(compiler);
-    int parameterCount = parameters.parameterCount;
-    if (argumentCount > parameterCount) return false;
+    if (argumentCount > parameters.parameterCount) return false;
+    int requiredParameterCount = parameters.requiredParameterCount;
+    int optionalParameterCount = parameters.optionalParameterCount;
 
     bool hasOptionalParameters = !parameters.optionalParameters.isEmpty();
     if (namedArguments.isEmpty()) {
       if (!hasOptionalParameters) {
-        return parameterCount == argumentCount;
+        return requiredParameterCount == argumentCount;
       } else {
-        int optionalParameterCount = parameters.optionalParameterCount;
-        return argumentCount >= parameterCount &&
-          argumentCount <= parameterCount + optionalParameterCount;
+        return argumentCount >= requiredParameterCount &&
+            argumentCount <= requiredParameterCount + optionalParameterCount;
       }
     } else {
       if (!hasOptionalParameters) return false;
+      Link<Element> remainingNamedParameters = parameters.optionalParameters;
+      for (int i = requiredParameterCount; i < positionalArgumentCount; i++) {
+        remainingNamedParameters = remainingNamedParameters.tail;
+      }
+      Set<SourceString> nameSet = new Set<SourceString>();
+      for (;
+           !remainingNamedParameters.isEmpty();
+           remainingNamedParameters = remainingNamedParameters.tail) {
+        nameSet.add(remainingNamedParameters.head.name);
+      }
+
       for (SourceString name in namedArguments) {
-        compiler.cancel('unimplemented named constructors');
+        if (!nameSet.contains(name)) {
+          return false;
+        }
+        nameSet.remove(name);
       }
       return true;
     }
   }
 
 
   static bool sameNames(List<SourceString> first, List<SourceString> second) {
     for (int i = 0; i < first.length; i++) {
       return first[i] == second[i];
     }
     return true;
   }
 
   bool operator ==(other) {
     if (other is !Invocation) return false;
     return argumentCount == other.argumentCount
            && namedArguments.length == other.namedArguments.length
            && sameNames(namedArguments, other.namedArguments);
   }
 }
 
 class Invocation extends Selector {
   final List<SourceString> namedArguments;
+  int get namedArgumentCount() => namedArguments.length;
+  int get positionalArgumentCount() => argumentCount - namedArgumentCount;
 
   const Invocation(
       int argumentCount,
       [List<SourceString> this.namedArguments = const <SourceString>[]])
     : super(SelectorKind.INVOCATION, argumentCount);
 }