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 {
+        return namedArguments.isEmpty();

[kasperl, 2012/09/12 08:23:13]

Somehow this case looks too simple. If the optional parameters are positional
then we allow cases where the positionalArgumentCount is higher than the
optionalParameterCount as long as there are no named arguments?

[ngeoffray, 2012/09/12 09:14:35]

It is that simple :) As discussed, I added a comment. The check line 213 covers
it.

+      }
+    } else {
+      if (positionalArgumentCount > requiredParameterCount) return false;
+      if (namedArgumentCount > optionalParameterCount) return false;

[kasperl, 2012/09/12 08:23:13]

Where do we weed out passing the same name more than once? I guess this check
depends on that. Probably fine.

[ngeoffray, 2012/09/12 09:14:35]

The check must be done in the resolver, but we're currently doing it here line
233. Added a TODO.

+      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;
+        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));
@@ skipping 22 matching lines @@
           foundIndex = i;
           break;
         }
       }
       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) {
+        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 = -1;

[kasperl, 2012/09/12 08:23:13]

namedArguments.indexOf(element.name)?

[ngeoffray, 2012/09/12 09:14:35]

Done.

+        for (int i = 0; i < namedArguments.length; i++) {
+          SourceString name = namedArguments[i];
+          if (name == element.name) {
+            foundIndex = i;
+            break;
+          }
+        }
+        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;
   }
 }