Drop trailing null arguments in generated JS.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 453 matching lines @@
       js.Expression result = sequenceElements.removeLast();
       while (sequenceElements.isNotEmpty) {
         result = new js.Binary(',', sequenceElements.removeLast(), result);
       }
       return result;
     }
   }
 
   /**
     * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET].
+    * Also, skip all trailing constant `null` arguments. JavaScript will fill
+    * missing arguments with `undefined` anyway. For functions that rely on
+    * 'arguments.length' in JavaScript, [allArgsRequired] should be set to
+    * `true`.
     */
   List<js.Expression> visitArguments(List<HInstruction> inputs,
-                                     {int start: HInvoke.ARGUMENTS_OFFSET}) {
+                                     {int start: HInvoke.ARGUMENTS_OFFSET,
+                                      bool allArgsRequired: false}) {
     assert(inputs.length >= start);
-    List<js.Expression> result = new List<js.Expression>(inputs.length - start);
-    for (int i = start; i < inputs.length; i++) {
+    int max;
+    if (allArgsRequired) {
+      max = inputs.length;
+    } else {
+      for (max = inputs.length; max > start; --max) {
+        HInstruction input = inputs[max-1];
+        if (input is! HConstant) break;
+        HConstant constant = input;
+        if (!constant.constant.isNull) break;
+      }
+    }
+    List<js.Expression> result = new List<js.Expression>(max - start);
+    for (int i = start; i < max; i++) {
       use(inputs[i]);
       result[i - start] = pop();
     }
     return result;
   }
 
   bool isVariableDeclared(String variableName) {
     return declaredLocals.contains(variableName) ||
         collectedVariableDeclarations.contains(variableName);
   }
@@ skipping 1016 matching lines @@
     List<js.Expression> arguments = <js.Expression>[pop()];
     push(jsPropertyCall(isolate, name, arguments), node);
     registry.registerUseInterceptor();
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     String name = node.selector.name;
     String methodName;
-    List<js.Expression> arguments = visitArguments(node.inputs);
+    bool allArgsRequired = false;
     Element target = node.element;
 
     if (target != null && !node.isInterceptedCall) {
       if (target == backend.jsArrayAdd) {
         methodName = 'push';
+        allArgsRequired = true;
       } else if (target == backend.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == backend.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
         registry.registerInstantiatedClass(compiler.listClass);
-      } else if (target.isNative && target.isFunction
-                 && !node.isInterceptedCall) {
+      } else if (target.isNative && target.isFunction) {
         // A direct (i.e. non-interceptor) native call is the result of
         // optimization.  The optimization ensures any type checks or
         // conversions have been satisified.
         methodName = target.fixedBackendName;
+        // TODO(herhut): Add notion of allArgsRequired to native annotations.
+        allArgsRequired = true;
       }
     }
+    // TODO(herhut): Add proper calling conventions to encode when arguments
+    //               may be dropped.
+    List<js.Expression> arguments = visitArguments(node.inputs,
+        allArgsRequired: allArgsRequired);
 
     if (methodName == null) {
       methodName = backend.namer.invocationName(node.selector);
       registerMethodInvoke(node);
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   void visitInvokeConstructorBody(HInvokeConstructorBody node) {
     use(node.inputs[0]);
@@ skipping 1166 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }