Support named arguments for statically resolved calls.

frog/leg/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 215 matching lines @@
   final SourceString name = identifier.source;
   Element element = compiler.universe.find(name);
   if (element !== null && element.kind === ElementKind.CLASS) {
     // TODO(karlklose): substitute type parameters.
     return element.computeType(compiler);
   }
   return types.lookup(name);
 }
 
 class FunctionParameters {
-  Link<Element> parameters;
+  Link<Element> requiredParameters;
   Link<Element> optionalParameters;
-  int parameterCount;
+  int requiredParameterCount;
   int optionalParameterCount;
-  FunctionParameters(this.parameters,
+  FunctionParameters(this.requiredParameters,
                      this.optionalParameters,
-                     this.parameterCount,
+                     this.requiredParameterCount,
                      this.optionalParameterCount);
 
   void forEachParameter(void function(Element parameter)) {
-    for (Link<Element> link = parameters;
+    for (Link<Element> link = requiredParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
     for (Link<Element> link = optionalParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
   }
+
+  int get parameterCount() => requiredParameterCount + optionalParameterCount;
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
   FunctionParameters functionParameters;
 
   FunctionElement(SourceString name,
                   ElementKind kind,
@@ skipping 23 matching lines @@
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
   FunctionParameters computeParameters(Compiler compiler) {
     if (functionParameters !== null) return functionParameters;
     functionParameters = compiler.resolveSignature(this);
     return functionParameters;
   }
 
+  int requiredParameterCount(Compiler compiler) {
+    return computeParameters(compiler).requiredParameterCount;
+  }
+
+  int optionalParameterCount(Compiler compiler) {
+    return computeParameters(compiler).optionalParameterCount;
+  }
+
   int parameterCount(Compiler compiler) {
     return computeParameters(compiler).parameterCount;
   }
 
-  int optionalParameterCount(Compiler compiler) {
-    return computeParameters(compiler).optionalParameterCount;
-  }
-
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     FunctionParameters parameters = computeParameters(compiler);
     Types types = compiler.types;
     FunctionExpression node =
         compiler.parser.measure(() => parseNode(compiler));
     Type returnType = getType(node.returnType, compiler, types);
     if (returnType === null) returnType = types.dynamicType;
 
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
-    for (Link<Element> link = parameters.parameters;
+    for (Link<Element> link = parameters.requiredParameters;
          !link.isEmpty();
          link = link.tail) {
       parameterTypes.addLast(link.head.computeType(compiler));
     }
     type = new FunctionType(returnType, parameterTypes.toLink(), this);
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) => cachedNode;
 
@@ skipping 195 matching lines @@
     else if (str === '>=') str = 'ge';
     else if (str === '>') str = 'gt';
     else if (str === '<=') str = 'le';
     else if (str === '<') str = 'lt';
     else if (str === '&' || str === '&=') str = 'and';
     else if (str === '^' || str === '^=') str = 'xor';
     else if (str === '|' || str === '|=') str = 'or';
     return new SourceString('$receiver\$$str');
   }
 }