Address Peter's comments on the new parameter specification implementation.

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 342 matching lines @@
                         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
+      // If the selector has the same number of named arguments as
       // 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.
-    // 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);
-    // (6) foo(1, 2, c: 3, d: 4);
-    // (7) foo(1, 2, d: 4, c: 3);
-    //
-    // What we generate at the call sites are:
-    // (1) foo$4(1, 2, 3, 4)
-    // (2) foo$2(1, 2);
-    // (3) foo$3(1, 2, 3);
-    // (4) foo$3$c(1, 2, 3);
-    // (5) foo$3$d(1, 2, 4);
-    // (6) foo$4$c$d(1, 2, 3, 4);
-    // (7) foo$4$c$d(1, 2, 3, 4);
-    //
-    // The stubs we generate are (expressed in Dart):
-    // (1) No stub generated, call is direct.
-    // (2) foo$2(a, b) => foo$4(a, b, null, null)
-    // (3) foo$3(a, b, c) => foo$4(a, b, c, null)
-    // (4) foo$3$c(a, b, c) => foo$4(a, b, c, null);
-    // (5) foo$3$d(a, b, d) => foo$4(a, b, null, d);
-    // (6) foo$4$c$d(a, b, c, d) => foo$4(a, b, c, d);
-    // (7) Same as (5).
-    //
-    // We need to generate a stub for (5) because the order of the
-    // stub arguments and the real method may be different.
-
     int count = 0;
     int indexOfLastOptionalArgumentInParameters = positionalArgumentCount - 1;
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     parameters.forEachParameter((Element element) {
       String jsName = JsNames.getValid(element.name.slowToString());
       if (count < positionalArgumentCount) {
         parametersBuffer[count] = jsName;
         argumentsBuffer[count] = jsName;
@@ skipping 38 matching lines @@
     } else {
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
     }
     buffer.add('\n}');
     defineInstanceMember(invocationName, buffer);
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineMemberFunction defineInstanceMember) {
+    // TODO(5074): Update this comment once we remove support for
+    // the deprecated parameter specification.
+    // 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);
+    // (6) foo(1, 2, c: 3, d: 4);
+    // (7) foo(1, 2, d: 4, c: 3);
+    //
+    // What we generate at the call sites are:
+    // (1) foo$4(1, 2, 3, 4)
+    // (2) foo$2(1, 2);
+    // (3) foo$3(1, 2, 3);
+    // (4) foo$3$c(1, 2, 3);
+    // (5) foo$3$d(1, 2, 4);
+    // (6) foo$4$c$d(1, 2, 3, 4);
+    // (7) foo$4$c$d(1, 2, 3, 4);
+    //
+    // The stubs we generate are (expressed in Dart):
+    // (1) No stub generated, call is direct.
+    // (2) foo$2(a, b) => foo$4(a, b, null, null)
+    // (3) foo$3(a, b, c) => foo$4(a, b, c, null)
+    // (4) foo$3$c(a, b, c) => foo$4(a, b, c, null);
+    // (5) foo$3$d(a, b, d) => foo$4(a, b, null, d);
+    // (6) foo$4$c$d(a, b, c, d) => foo$4(a, b, c, d);
+    // (7) Same as (5).
+    //
+    // We need to generate a stub for (5) because the order of the
+    // stub arguments and the real method may be different.
     Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(member, compiler)) continue;
       addParameterStub(member, selector, defineInstanceMember);
     }
   }
 
   bool instanceFieldNeedsGetter(Element member) {
     assert(member.isField());
@@ skipping 563 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.instanceMethodNameByArity(Compiler.NO_SUCH_METHOD, 2);
+        namer.publicInstanceMethodNameByArity(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 295 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].
 """;