Support named arguments for dynamic calls.

frog/leg/emitter.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.
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
@@ skipping 23 matching lines @@
     addedInheritFunction = true;
     buffer.add('$inheritsName = ');
     buffer.add(INHERIT_FUNCTION);
     buffer.add(';\n');
   }
 
   void addParameterStub(FunctionElement member,
                         String prototype,
                         StringBuffer buffer,
                         Invocation invocation) {
-    // TODO(ngeoffray): also support invocation with names.
+    FunctionParameters parameters = member.computeParameters(compiler);
+    int positionalArgumentCount = invocation.positionalArgumentCount;
+    if (positionalArgumentCount == parameters.parameterCount) return;
+    List<SourceString> names = invocation.orderedNamedArguments;
+    assert(names.length == invocation.namedArguments.length);
+
     String invocationName =
-        namer.instanceMethodName(member.name, invocation.argumentCount);
-    int allParameters = member.parameterCount(compiler);
-    int missingParameters = allParameters - invocation.argumentCount;
-    if (missingParameters == 0) return;
-    assert(missingParameters > 0);
+        namer.instanceMethodInvocationName(member.name, invocation);
     buffer.add('$prototype.$invocationName = function(');
-    StringBuffer parameters = new StringBuffer();
-    for (int i = 0; i < invocation.argumentCount; i++) {
-      if (i != 0) parameters.add(', ');
-      parameters.add('param$i');
+
+    // The parameters that this stub takes.

[kasperl, 2012/02/01 10:21:21]

Maybe you could write a comment with a few examples that illustrate how this
works?

[ngeoffray, 2012/02/01 11:44:15]

Done.

+    StringBuffer parametersBuffer = new StringBuffer();
+    // The missing and named arguments that will be passed to the real
+    // method.
+    StringBuffer missingAndNamedArgumentsBuffer = new StringBuffer();
+    StringBuffer positionalArgumentsBuffer = new StringBuffer();
+
+    int count = 0;
+    parameters.forEachParameter((Element element) {
+      if (count < positionalArgumentCount) {
+        if (count != 0) parametersBuffer.add(', ');
+        parametersBuffer.add('${element.name}');
+        positionalArgumentsBuffer.add('${element.name}');
+      } else {
+        if (count != positionalArgumentCount || positionalArgumentCount != 0) {
+          missingAndNamedArgumentsBuffer.add(', ');
+        }
+        int index = names.indexOf(element.name);
+        if (index != -1) {
+          // The order of the named arguments is not the same as the
+          // one in the real method (which is in Dart source order).
+          // Therefore, we don't add the argument to the
+          // [parametersBuffer] just yet.
+          missingAndNamedArgumentsBuffer.add('${element.name}');
+        } else {
+          // TODO(ngeoffray): Get the default value.
+          missingAndNamedArgumentsBuffer.add('(void 0)');
+        }
+      }
+      count++;
+    });
+
+    // Add the named arguments to the parametersBuffer.
+    for (SourceString name in names) {
+      if (positionalArgumentCount != 0) parametersBuffer.add(', ');
+      parametersBuffer.add(name);
     }
-    buffer.add('$parameters) {\n');
-    buffer.add('  this.${namer.getName(member)}($parameters');
-    for (int i = 0; i < missingParameters; i++) {
-      if (i != 0 || invocation.argumentCount != 0) buffer.add(', ');
-      buffer.add('(void 0)');
-    }
-    buffer.add(')\n}\n');
+
+    buffer.add('$parametersBuffer) {\n');
+    buffer.add('  return this.${namer.getName(member)}');
+    buffer.add('($positionalArgumentsBuffer$missingAndNamedArgumentsBuffer)');
+    buffer.add('\n}\n');
   }
 
   void addParameterStubs(FunctionElement member,
                          String prototype,
                          StringBuffer buffer) {
     Set<Invocation> invocations = compiler.universe.invokedNames[member.name];
     if (invocations == null) return;
     for (Invocation invocation in invocations) {
       if (!invocation.applies(compiler, member)) continue;
       addParameterStub(member, prototype, buffer, invocation);
@@ skipping 214 matching lines @@
       emitStaticFunctions(buffer);
       emitStaticFinalFieldInitializations(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       Element main = compiler.universe.find(Compiler.MAIN);
       buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }