Runtime support for the new parameter specification.

lib/compiler/implementation/universe/universe.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.
 
 #library('universe');
 
 #import('../closure.dart');
 #import('../elements/elements.dart');
 #import('../leg.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 197 matching lines @@
     if (element.isField()) return isGetter() || isSetter() || isCall();
     if (isGetter()) return true;
 
     FunctionElement function = element;
     FunctionSignature parameters = function.computeSignature(compiler);
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
+    if (!parameters.optionalParametersAreNamed) {
+      if (!Compiler.REJECT_NAMED_ARGUMENT_AS_POSITIONAL) {
+        return optionalParametersAppliesDEPRECATED(element, compiler);
+      } else {
+        // We have already checked that the number of arguments are
+        // not greater than the number of parameters. Therefore the
+        // number of positional arguments are not greater than the
+        // number of parameters.
+        assert(positionalArgumentCount <= parameters.parameterCount);
+        return namedArguments.isEmpty();
+      }
+    } else {
+      if (positionalArgumentCount > requiredParameterCount) return false;

[ahe, 2012/09/13 14:29:10]

assert(positionalArgumentCount == requiredParameterCount);

[ngeoffray, 2012/09/17 12:21:01]

Done.

+      if (namedArgumentCount > optionalParameterCount) return false;
+      Set<SourceString> nameSet = new Set<SourceString>();
+      parameters.optionalParameters.forEach((Element element) {
+        nameSet.add(element.name);
+      });
+      for (SourceString name in namedArguments) {
+        if (!nameSet.contains(name)) return false;
+        // TODO(ngeoffray): By removing from the set we are checking

[ahe, 2012/09/13 14:29:10]

Perhaps Jamie would like to look at that. File a bug.

[ngeoffray, 2012/09/17 12:21:01]

Done: http://code.google.com/p/dart/issues/detail?id=5213

+        // that we are not passing the name twice. We should have this
+        // check in the resolver instead.
+        nameSet.remove(name);
+      }
+      return true;
+    }
+  }
+
+  // TODO(5074): Remove this method once we don't accept the
+  // deprecated parameter specification.
+  bool optionalParametersAppliesDEPRECATED(FunctionElement function,
+                                           Compiler compiler) {
+    FunctionSignature parameters = function.computeSignature(compiler);
+    int requiredParameterCount = parameters.requiredParameterCount;
+    int optionalParameterCount = parameters.optionalParameterCount;
+
     bool hasOptionalParameters = !parameters.optionalParameters.isEmpty();
     if (namedArguments.isEmpty()) {
       if (!hasOptionalParameters) {
         return requiredParameterCount == argumentCount;
       } else {
         return argumentCount >= requiredParameterCount &&
             argumentCount <= requiredParameterCount + optionalParameterCount;
       }
     } else {
       if (!hasOptionalParameters) return false;
@@ skipping 11 matching lines @@
       for (SourceString name in namedArguments) {
         if (!nameSet.contains(name)) {
           return false;
         }
         nameSet.remove(name);
       }
       return true;
     }
   }
 
-  /**
-   * Returns [:true:] if the selector and the [element] match; [:false:]
-   * otherwise.
-   */
-  bool addArgumentsToList(Link<Node> arguments,
-                          List list,
-                          FunctionElement element,
-                          compileArgument(Node argument),
-                          compileConstant(Element element),
-                          Compiler compiler) {
-    if (!this.applies(element, compiler)) return false;
-
-    void addMatchingArgumentsToList(Link<Node> link) {}
-
-    FunctionSignature parameters = element.computeSignature(compiler);
-    if (this.positionalArgumentCount == parameters.parameterCount) {
-      for (Link<Node> link = arguments; !link.isEmpty(); link = link.tail) {
-        list.add(compileArgument(link.head));
-      }
-      return true;
-    }
-
+  // TODO(5074): Remove this method once we don't accept the
+  // deprecated parameter specification.
+  bool addOptionalArgumentsToListDEPRECATED(Link<Node> arguments,
+                                            List list,
+                                            FunctionElement element,
+                                            compileArgument(Node argument),
+                                            compileConstant(Element element),
+                                            Compiler compiler) {
     // If there are named arguments, provide them in the order
     // expected by the called function, which is the source order.
+    FunctionSignature parameters = element.computeSignature(compiler);
 
     // Visit positional arguments and add them to the list.
-    int positionalArgumentCount = this.positionalArgumentCount;
-    for (int i = 0;
+    for (int i = parameters.requiredParameterCount;
          i < positionalArgumentCount;
          arguments = arguments.tail, i++) {
       list.add(compileArgument(arguments.head));
     }
 
     // Visit named arguments and add them into a temporary list.
     List compiledNamedArguments = [];
     for (; !arguments.isEmpty(); arguments = arguments.tail) {
       NamedArgument namedArgument = arguments.head;
       compiledNamedArguments.add(compileArgument(namedArgument.expression));
     }
 
     Link<Element> remainingNamedParameters = parameters.optionalParameters;
     // Skip the optional parameters that have been given in the
     // positional arguments.
     for (int i = parameters.requiredParameterCount;
          i < positionalArgumentCount;
          i++) {
       remainingNamedParameters = remainingNamedParameters.tail;
     }
 
     // Loop over the remaining named parameters, and try to find
     // their values: either in the temporary list or using the
     // default value.
     for (;
          !remainingNamedParameters.isEmpty();
          remainingNamedParameters = remainingNamedParameters.tail) {
       Element parameter = remainingNamedParameters.head;
-      int foundIndex = -1;
-      for (int i = 0; i < namedArguments.length; i++) {
-        SourceString name = namedArguments[i];
-        if (name == parameter.name) {
-          foundIndex = i;
-          break;
-        }
-      }
+      int foundIndex = namedArguments.indexOf(parameter.name);
       if (foundIndex != -1) {
         list.add(compiledNamedArguments[foundIndex]);
       } else {
         list.add(compileConstant(parameter));
       }
     }
+  }
+
+
+  /**
+   * Returns [:true:] if the selector and the [element] match; [:false:]
+   * otherwise.
+   */
+  bool addArgumentsToList(Link<Node> arguments,
+                          List list,
+                          FunctionElement element,
+                          compileArgument(Node argument),
+                          compileConstant(Element element),
+                          Compiler compiler) {
+    if (!this.applies(element, compiler)) return false;
+
+    FunctionSignature parameters = element.computeSignature(compiler);
+    parameters.forEachRequiredParameter((element) {
+      list.add(compileArgument(arguments.head));
+      arguments = arguments.tail;
+    });
+
+    if (!parameters.optionalParametersAreNamed) {
+      if (!Compiler.REJECT_NAMED_ARGUMENT_AS_POSITIONAL) {

[ahe, 2012/09/13 14:29:10]

TODO?

[ngeoffray, 2012/09/17 12:21:01]

Done.

+        addOptionalArgumentsToListDEPRECATED(
+            arguments, list, element, compileArgument, compileConstant,
+            compiler);
+      } else {
+        parameters.forEachOptionalParameter((element) {
+          if (!arguments.isEmpty()) {
+            list.add(compileArgument(arguments.head));
+            arguments = arguments.tail;
+          } else {
+            list.add(compileConstant(element));
+          }
+        });
+      }
+    } else {
+      // Visit named arguments and add them into a temporary list.
+      List compiledNamedArguments = [];
+      for (; !arguments.isEmpty(); arguments = arguments.tail) {
+        NamedArgument namedArgument = arguments.head;
+        compiledNamedArguments.add(compileArgument(namedArgument.expression));
+      }
+      // Iterate over the optional parameters of the signature, and try to
+      // find them in [compiledNamedArguments]. If found, we use the
+      // value in the temporary list, otherwise the default value.
+      parameters.forEachOptionalParameter((element) {
+        int foundIndex = namedArguments.indexOf(element.name);
+        if (foundIndex != -1) {
+          list.add(compiledNamedArguments[foundIndex]);
+        } else {
+          list.add(compileConstant(element));
+        }
+      });
+    }
     return true;
   }
 
   static bool sameNames(List<SourceString> first, List<SourceString> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
   }
 
@@ skipping 100 matching lines @@
 
     if (!self.isInterface() && self.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && appliesUntyped(element, compiler);
     }
 
     return false;
   }
 }