Runtime support for the new parameter specification.

lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 331 matching lines @@
    */
   void addParameterStub(FunctionElement member,
                         Selector selector,
                         DefineMemberFunction defineInstanceMember) {
     FunctionSignature parameters = member.computeSignature(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
+    if (parameters.optionalParametersAreNamed
+        && selector.namedArgumentCount == parameters.optionalParameterCount) {
+      // If the selector has the same number of named arguments than

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

than -> as

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

Done.

+      // the element, we don't need to add a stub. The call site will
+      // hit the method directly.
+      return;
+    }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
         namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                            selector);
     CodeBuffer buffer = new CodeBuffer();
     buffer.add('function(');
 
     // The parameters that this stub takes.
     List<String> parametersBuffer = new List<String>(selector.argumentCount);
     // The arguments that will be passed to the real method.
     List<String> argumentsBuffer = new List<String>(parameters.parameterCount);
 
+    // TODO(5074): Update this comment once we remove support for
+    // the deprecated parameter specification.

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

Actually, I think this comment should be moved to addParameterStubs (plural).

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

Done.

     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, [c, d]);
     //
     // We may have multiple ways of calling foo:
     // (1) foo(1, 2, 3, 4)
     // (2) foo(1, 2);
     // (3) foo(1, 2, 3);
     // (4) foo(1, 2, c: 3);
     // (5) foo(1, 2, d: 4);
@@ skipping 427 matching lines @@
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
       String staticName = namer.getName(element);
-      int parameterCount = element.parameterCount(compiler);
-      String invocationName =
-          namer.instanceMethodName(element.getLibrary(), callElement.name,
-                                   parameterCount);
+      String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
       addParameterStubs(callElement, (String name, CodeBuffer value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
@@ skipping 44 matching lines @@
  ['self', 'target'],
  'super': '$superName',
 """);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
 
-      String invocationName =
-          namer.instanceMethodName(member.getLibrary(),
-                                   callElement.name, parameterCount);
+      String invocationName = namer.instanceMethodName(callElement);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
           "$invocationName: function($joinedArgs) {");
       boundClosureBuffer.add(" return this.self[this.target]($joinedArgs);");
       boundClosureBuffer.add(" }");
       addParameterStubs(callElement, (String stubName, CodeBuffer memberValue) {
         boundClosureBuffer.add(',\n $stubName: $memberValue');
       });
       boundClosureBuffer.add("\n};\n");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (!hasOptionalParameters) {
         boundClosureCache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
-    String targetName = namer.instanceMethodName(member.getLibrary(),
-                                                 member.name, parameterCount);
+    String targetName = namer.instanceMethodName(member);
     CodeBuffer getterBuffer = new CodeBuffer();
     getterBuffer.add(
         "function() { return new $closureClass(this, '$targetName'); }");
     defineInstanceMember(getterName, getterBuffer);
   }
 
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineMemberFunction defineInstanceMember) {
     String getter;
@@ skipping 114 matching lines @@
         emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
   }
 
   void emitNoSuchMethodHandlers(DefineMemberFunction defineInstanceMember) {
     // Do not generate no such method handlers if there is no class.
     if (compiler.codegenWorld.instantiatedClasses.isEmpty()) return;
 
     String noSuchMethodName =
-        namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
+        namer.instanceMethodNameByArity(Compiler.NO_SUCH_METHOD, 2);
 
     // Keep track of the JavaScript names we've already added so we
     // do not introduce duplicates (bad for code size).
     Set<String> addedJsNames = new Set<String>();
 
     // Keep track of the noSuchMethod holders for each possible
     // receiver type.
     Map<ClassElement, Set<ClassElement>> noSuchMethodHolders =
         new Map<ClassElement, Set<ClassElement>>();
     Set<ClassElement> noSuchMethodHoldersFor(DartType type) {
@@ skipping 292 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;