dart2js: Use correct call structures throughout the backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 167 matching lines @@
    * Builds the [ir.FunctionDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
   ir.FunctionDefinition buildExecutable(ExecutableElement element);
 
   ClosureClassMap get closureClassMap;
   ClosureScope getClosureScopeForNode(ast.Node node);
   ClosureEnvironment getClosureEnvironment();
 
-  /// Normalizes the argument list to a static invocation (i.e. where the target
-  /// element is known).
+  /// Normalizes the argument list of a static invocation.
   ///
-  /// For the JS backend, inserts default arguments and normalizes order of
-  /// named arguments.
-  ///
-  /// For the Dart backend, returns [arguments].
-  List<ir.Primitive> normalizeStaticArguments(
+  /// A static invocation is one where the target is known.  The argument list
+  /// [arguments] is normalized by adding default values for optional arguments
+  /// that are not passed, and by sorting it in place so that named arguments
+  /// appear in a canonical order.  A [CallStructure] reflecting this order
+  /// is returned.
+  CallStructure normalizeStaticArguments(
       CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments);
 
-  /// Normalizes the argument list of a dynamic invocation (i.e. where the
-  /// target element is unknown).
+  /// Normalizes the argument list of a dynamic invocation.
   ///
-  /// For the JS backend, normalizes order of named arguments.
-  ///
-  /// For the Dart backend, returns [arguments].
-  List<ir.Primitive> normalizeDynamicArguments(
+  /// A dynamic invocation is one where the target is not known.  The argument
+  /// list [arguments] is normalized by sorting it in place so that the named
+  /// arguments appear in a canonical order.  A [CallStructure] reflecting this
+  /// order is returned.
+  CallStructure normalizeDynamicArguments(
       CallStructure callStructure,
       List<ir.Primitive> arguments);
 
   /// Read the value of [field].
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src);
 
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<Local> parameters = <Local>[];
@@ skipping 92 matching lines @@
       if (parameter.isNamed) {
         namedParameters.add(parameter.name);
       }
     });
     ClassElement cls = redirectingConstructor.enclosingClass;
     InterfaceType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
     CallStructure callStructure = new CallStructure(
         redirectingSignature.parameterCount,
         namedParameters);
-    arguments = normalizeStaticArguments(callStructure, targetConstructor,
-        arguments);
+    callStructure =
+        normalizeStaticArguments(callStructure, targetConstructor, arguments);
     ir.Primitive instance = irBuilder.buildConstructorInvocation(
         targetConstructor,
         callStructure,
         targetType,
         arguments,
         sourceInformationBuilder.buildNew(node));
     irBuilder.buildReturn(
         value: instance,
         sourceInformation: sourceInformationBuilder.buildReturn(node));
   }
@@ skipping 381 matching lines @@
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
                                      ast.NodeList argumentsNode,
                                      CallStructure callStructure, _) {
     ir.Primitive receiver = visit(expression);
-    List<ir.Primitive> arguments = node.arguments.mapToList(visit);
-    arguments = normalizeDynamicArguments(callStructure, arguments);
-    return irBuilder.buildCallInvocation(
-        receiver, callStructure, arguments,
+    List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
+    callStructure = normalizeDynamicArguments(callStructure, arguments);
+    return irBuilder.buildCallInvocation(receiver, callStructure, arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
@@ skipping 207 matching lines @@
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
         value, type, isTypeTest: true);
     return irBuilder.buildNegation(check);
   }
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
+    ir.Primitive receiver = visit(left);
     Selector selector = new Selector.binaryOperator(operator.selectorName);
-    ir.Primitive receiver = visit(left);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
-    arguments = normalizeDynamicArguments(selector.callStructure, arguments);
+    CallStructure callStructure =
+        normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
-        receiver, selector, elements.getTypeMask(node), arguments,
+        receiver,
+        new Selector(selector.kind, selector.memberName, callStructure),
+        elements.getTypeMask(node),
+        arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
     return translateBinary(node, left, operator, right);
   }
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
+    ir.Primitive target = visit(receiver);
     Selector selector = new Selector.index();
-    ir.Primitive target = visit(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
-    arguments = normalizeDynamicArguments(selector.callStructure, arguments);
+    CallStructure callStructure =
+        normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
-        target, selector, elements.getTypeMask(node), arguments,
+        target,
+        new Selector(selector.kind, selector.memberName, callStructure),
+        elements.getTypeMask(node),
+        arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(receiver, node.selector));
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
-    CallStructure callStructure = CallStructure.ONE_ARG;
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
-    arguments = normalizeDynamicArguments(callStructure, arguments);
+    CallStructure callStructure =
+        normalizeDynamicArguments(CallStructure.ONE_ARG, arguments);
     return irBuilder.buildSuperMethodInvocation(
         function, callStructure, arguments);
   }
 
   @override
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
@@ skipping 73 matching lines @@
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
         function, CallStructure.NO_ARGS, const []);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
-  List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
-                                               CallStructure callStructure) {
-    List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
+  CallStructure translateDynamicArguments(ast.NodeList nodeList,
+                                          CallStructure callStructure,
+                                          List<ir.Primitive> arguments) {
+    assert(arguments.isEmpty);
+    for (ast.Node node in nodeList) arguments.add(visit(node));
     return normalizeDynamicArguments(callStructure, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
-  List<ir.Primitive> translateStaticArguments(ast.NodeList nodeList,
-                                              Element element,
-                                              CallStructure callStructure) {
-    List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
+  CallStructure translateStaticArguments(ast.NodeList nodeList,
+                                         Element element,
+                                         CallStructure callStructure,
+                                         List<ir.Primitive> arguments) {
+    assert(arguments.isEmpty);
+    for (ast.Node node in nodeList) arguments.add(visit(node));
     return normalizeStaticArguments(callStructure, element, arguments);
   }
 
   ir.Primitive translateCallInvoke(ir.Primitive target,
-                                   ast.NodeList arguments,
+                                   ast.NodeList argumentsNode,
                                    CallStructure callStructure,
                                    SourceInformation sourceInformation) {
-
-    return irBuilder.buildCallInvocation(target, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildCallInvocation(target, callStructure, arguments,
         sourceInformation: sourceInformation);
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = buildConstantExpression(constant,
         sourceInformationBuilder.buildGet(node));
     return translateCallInvoke(target, arguments, callStructure,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       Selector selector,
       _) {
+    ir.Primitive target = translateReceiver(receiver);
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    CallStructure callStructure = translateDynamicArguments(
+        argumentsNode, selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
-        translateReceiver(receiver), selector, elements.getTypeMask(node),
-        translateDynamicArguments(arguments, selector.callStructure),
+        target,
+        new Selector(selector.kind, selector.memberName, callStructure),
+        elements.getTypeMask(node),
+        arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
-        nested(() => irBuilder.buildDynamicInvocation(
-            target, selector, elements.getTypeMask(node),
-            translateDynamicArguments(arguments, selector.callStructure))));
+        nested(() {
+          List<ir.Primitive> arguments = <ir.Primitive>[];
+          CallStructure callStructure = translateDynamicArguments(
+              argumentsNode, selector.callStructure, arguments);
+          return irBuilder.buildDynamicInvocation(
+              target,
+              new Selector(selector.kind, selector.memberName, callStructure),
+              elements.getTypeMask(node),
+              arguments);
+        }));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalVariableInvocation(element, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildLocalVariableInvocation(
+        element,
+        callStructure,
+        arguments,
         callSourceInformation:
-            sourceInformationBuilder.buildCall(node, arguments));
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalFunctionInvocation(function, callStructure,
-        translateDynamicArguments(arguments, callStructure),
-        sourceInformationBuilder.buildCall(node, arguments));
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildLocalFunctionInvocation(
+        function,
+        callStructure,
+        arguments,
+        sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     ir.Primitive target = buildStaticFieldGet(field, src);
-    return irBuilder.buildCallInvocation(target,
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildCallInvocation(
+        target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure),
+        arguments,
         sourceInformation:
-            sourceInformationBuilder.buildCall(node, arguments));
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _);
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildStaticNoSuchMethod(
         elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildStaticGetterGet(
-        getter, sourceInformationBuilder.buildGet(node));
-    return irBuilder.buildCallInvocation(target,
+    ir.Primitive target = irBuilder.buildStaticGetterGet(getter,
+        sourceInformationBuilder.buildGet(node));
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildCallInvocation(
+        target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure),
+        arguments,
         sourceInformation:
-            sourceInformationBuilder.buildCall(node, arguments));
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildSuperFieldGet(field);
-    return irBuilder.buildCallInvocation(target,
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildCallInvocation(
+        target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure),
+        arguments,
         sourceInformation:
-            sourceInformationBuilder.buildCall(node, arguments));
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildSuperGetterGet(
-        getter, sourceInformationBuilder.buildGet(node));
-    return irBuilder.buildCallInvocation(target,
+    ir.Primitive target = irBuilder.buildSuperGetterGet(getter,
+        sourceInformationBuilder.buildGet(node));
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildCallInvocation(
+        target,
         callStructure,
-        translateDynamicArguments(arguments, callStructure),
+        arguments,
         sourceInformation:
-            sourceInformationBuilder.buildCall(node, arguments));
+            sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildSuperMethodInvocation(method, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return irBuilder.buildSuperMethodInvocation(
+        method,
+        callStructure,
+        arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure =
+      translateDynamicArguments(arguments, callStructure, normalizedArguments);
     return buildInstanceNoSuchMethod(
-        elements.getSelector(node),
+        new Selector.call(method.memberName, normalizedCallStructure),
         elements.getTypeMask(node),
-        translateDynamicArguments(arguments, callStructure));
+        normalizedArguments);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperInvoke(
       ast.Send node,
       Element element,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       Selector selector, _) {
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    CallStructure callStructure = translateDynamicArguments(
+        argumentsNode, selector.callStructure, arguments);
+    // TODO(johnniwinther): Supply a member name to the visit function instead
+    // of looking it up in elements.
     return buildInstanceNoSuchMethod(
-        elements.getSelector(node),
+        new Selector.call(elements.getSelector(node).memberName, callStructure),
         elements.getTypeMask(node),
-        translateDynamicArguments(arguments, selector.callStructure));
+        arguments);
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(
         irBuilder.buildThis(),
@@ skipping 57 matching lines @@
 
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
-    arguments = normalizeDynamicArguments(
-        operatorSelector.callStructure, arguments);
+    CallStructure callStructure =
+        normalizeDynamicArguments(operatorSelector.callStructure, arguments);
     TypeMask operatorTypeMask =
         elements.getOperatorTypeMaskInComplexSendSet(node);
     SourceInformation operatorSourceInformation =
         sourceInformationBuilder.buildCall(node, node.assignmentOperator);
     ir.Primitive result = irBuilder.buildDynamicInvocation(
-        value, operatorSelector, operatorTypeMask, arguments,
-            sourceInformation: operatorSourceInformation);
+        value,
+        new Selector(operatorSelector.kind, operatorSelector.memberName,
+            callStructure),
+        operatorTypeMask,
+        arguments,
+        sourceInformation: operatorSourceInformation);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   ir.Primitive translateSetIfNull(
       ast.SendSet node,
       {ir.Primitive getValue(),
        ast.Node rhs,
        void setValue(ir.Primitive value)}) {
     ir.Primitive value = getValue();
@@ skipping 458 matching lines @@
       ast.Node index,
       CompoundRhs rhs,
       arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
         node,
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          arguments =
+          CallStructure callStructure =
               normalizeDynamicArguments(selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(
               target,
-              selector,
+              new Selector(selector.kind, selector.memberName, callStructure),
               elements.getGetterTypeMaskInComplexSendSet(node),
               arguments,
               sourceInformation:
                   sourceInformationBuilder.buildCall(receiver, node));
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildDynamicIndexSet(
               target,
               elements.getTypeMask(node),
@@ skipping 125 matching lines @@
       Selector selector, _) {
     // If the class is missing it's a runtime error.
     return buildRuntimeError("Unresolved class: '${element.name}'");
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       Selector selector, _) {
     // If the class is there but the constructor is missing, it's an NSM error.
-    return buildStaticNoSuchMethod(selector,
-        translateDynamicArguments(arguments, selector.callStructure));
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    CallStructure callStructure = translateDynamicArguments(
+        argumentsNode, selector.callStructure, arguments);
+    return buildStaticNoSuchMethod(
+        new Selector(selector.kind, selector.memberName, callStructure),
+        arguments);
   }
 
   @override
   ir.Primitive visitConstructorIncompatibleInvoke(
       ast.NewExpression node,
-      Element constructor,
+      ConstructorElement constructor,
       DartType type,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
-    return buildStaticNoSuchMethod(elements.getSelector(node.send),
-        translateDynamicArguments(arguments, callStructure));
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
+    return buildStaticNoSuchMethod(
+        new Selector.call(constructor.memberName, callStructure), arguments);
   }
 
   @override
   ir.Primitive visitUnresolvedGet(
       ast.Send node,
       Element element, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
        ConstructorElement constructor,
        InterfaceType type,
-       ast.NodeList arguments,
+       ast.NodeList argumentsNode,
        CallStructure callStructure, _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
     return buildStaticNoSuchMethod(
         new Selector.call(name, callStructure),
-        translateDynamicArguments(arguments, callStructure));
+        arguments);
   }
 
   @override
   ir.Primitive visitUnresolvedSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);
   }
 
@@ skipping 152 matching lines @@
       _) {
     return buildStaticNoSuchMethod(
         new Selector.getter(setter.memberName),
         []);
   }
 
   @override
   ir.Primitive handleStaticSetterInvoke(
       ast.Send node,
       SetterElement setter,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     // Translate as a method call.
-    List<ir.Primitive> args = arguments.nodes.mapToList(visit);
+    List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     return buildStaticNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
-        args);
+        arguments);
   }
 
   @override
   ir.Primitive visitSuperGetterSet(
       ast.SendSet node,
       GetterElement getter,
       ast.Node rhs,
       _) {
     return buildInstanceNoSuchMethod(
         new Selector.setter(getter.memberName),
@@ skipping 20 matching lines @@
     return buildInstanceNoSuchMethod(
         new Selector.setter(setter.memberName),
         elements.getTypeMask(node),
         []);
   }
 
   @override
   ir.Primitive visitSuperSetterInvoke(
       ast.Send node,
       SetterElement setter,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
-    List<ir.Primitive> args =
-        translateDynamicArguments(arguments, callStructure);
+    List<ir.Primitive> arguments = <ir.Primitive>[];
+    callStructure =
+        translateDynamicArguments(argumentsNode, callStructure, arguments);
     return buildInstanceNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
         elements.getTypeMask(node),
-        args);
+        arguments);
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
@@ skipping 906 matching lines @@
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
       return irBuilder.buildNullConstant();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
     }
   }
 
-  /// Inserts default arguments and normalizes order of named arguments.
-  List<ir.Primitive> normalizeStaticArguments(
-      CallStructure callStructure,
-      FunctionElement target,
-      List<ir.Primitive> arguments) {
+  CallStructure normalizeStaticArguments(CallStructure callStructure,
+                                         FunctionElement target,
+                                         List<ir.Primitive> arguments) {
     target = target.implementation;
     FunctionSignature signature = target.functionSignature;
     if (!signature.optionalParametersAreNamed &&
         signature.parameterCount == arguments.length) {
-      // Optimization: don't copy the argument list for trivial cases.
-      return arguments;
+      return callStructure;
     }
 
-    List<ir.Primitive> result = <ir.Primitive>[];
-    int i = 0;
-    signature.forEachRequiredParameter((ParameterElement element) {
-      result.add(arguments[i]);
-      ++i;
-    });
-
     if (!signature.optionalParametersAreNamed) {
+      int i = signature.requiredParameterCount;
       signature.forEachOptionalParameter((ParameterElement element) {
-        if (i < arguments.length) {
-          result.add(arguments[i]);
+        if (i < callStructure.positionalArgumentCount) {
           ++i;
         } else {
-          result.add(translateDefaultValue(element));
+          arguments.add(translateDefaultValue(element));
         }
       });
-    } else {
-      int offset = i;
-      // 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.
-      signature.orderedOptionalParameters.forEach((ParameterElement element) {
-        int nameIndex = callStructure.namedArguments.indexOf(element.name);
-        if (nameIndex != -1) {
-          int translatedIndex = offset + nameIndex;
-          result.add(arguments[translatedIndex]);
-        } else {
-          result.add(translateDefaultValue(element));
-        }
-      });
+      return new CallStructure(signature.parameterCount);
     }
-    return result;
+
+    int offset = signature.requiredParameterCount;
+    List<ir.Primitive> namedArguments = arguments.sublist(offset);
+    arguments.length = offset;
+    List<String> normalizedNames = <String>[];
+    // Iterate over the optional parameters of the signature, and try to
+    // find them in the callStructure's named arguments. If found, we use the
+    // value in the temporary list, otherwise the default value.
+    signature.orderedOptionalParameters.forEach((ParameterElement element) {
+      int nameIndex = callStructure.namedArguments.indexOf(element.name);
+      arguments.add(nameIndex == -1 ? translateDefaultValue(element)
+                                    : namedArguments[nameIndex]);
+      normalizedNames.add(element.name);
+    });
+    return new CallStructure(signature.parameterCount, normalizedNames);
   }
 
-  /// Normalizes order of named arguments.
-  List<ir.Primitive> normalizeDynamicArguments(
-      CallStructure callStructure,
-      List<ir.Primitive> arguments) {
+  CallStructure normalizeDynamicArguments(CallStructure callStructure,
+                                          List<ir.Primitive> arguments) {
     assert(arguments.length == callStructure.argumentCount);
-    // Optimization: don't copy the argument list for trivial cases.
-    if (callStructure.namedArguments.isEmpty) return arguments;
-    List<ir.Primitive> result = <ir.Primitive>[];
-    for (int i=0; i < callStructure.positionalArgumentCount; i++) {
-      result.add(arguments[i]);
+    if (callStructure.namedArguments.isEmpty) return callStructure;
+    int destinationIndex = callStructure.positionalArgumentCount;
+    List<ir.Primitive> namedArguments = arguments.sublist(destinationIndex);
+    for (String argName in callStructure.getOrderedNamedArguments()) {
+      int sourceIndex = callStructure.namedArguments.indexOf(argName);
+      arguments[destinationIndex++] = namedArguments[sourceIndex];
     }
-    for (String argName in callStructure.getOrderedNamedArguments()) {
-      int nameIndex = callStructure.namedArguments.indexOf(argName);
-      int translatedIndex = callStructure.positionalArgumentCount + nameIndex;
-      result.add(arguments[translatedIndex]);
-    }
-    return result;
+    return new CallStructure(callStructure.argumentCount,
+                             callStructure.getOrderedNamedArguments());
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
-      ast.NodeList arguments,
+      ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    List<ir.Primitive> arguments =
-        node.send.arguments.mapToList(visit, growable:false);
+    List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     // Use default values from the effective target, not the immediate target.
     ConstructorElement target = constructor.effectiveTarget;
-    arguments = normalizeStaticArguments(callStructure, target, arguments);
+    callStructure =
+        normalizeStaticArguments(callStructure, target, arguments);
     TypeMask allocationSiteType;
     ast.Node send = node.send;
     if (Elements.isFixedListConstructorCall(constructor, send, compiler) ||
         Elements.isGrowableListConstructorCall(constructor, send, compiler) ||
         Elements.isFilledListConstructorCall(constructor, send, compiler) ||
         Elements.isConstructorOfTypedArraySubclass(constructor, compiler)) {
       allocationSiteType = getAllocationSiteType(send);
     }
     return irBuilder.buildConstructorInvocation(
         target,
@@ skipping 90 matching lines @@
     }
 
     /// Call a helper method from the isolate library. The isolate library uses
     /// its own isolate structure, that encapsulates dart2js's isolate.
     ir.Primitive buildIsolateHelperInvocation(Element element,
                                               CallStructure callStructure) {
       if (element == null) {
         reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
-      List<ir.Primitive> arguments = translateStaticArguments(argumentList,
-          element, callStructure);
-      return irBuilder.buildStaticFunctionInvocation(element,
-          callStructure, arguments,
+      List<ir.Primitive> arguments = <ir.Primitive>[];
+      callStructure = translateStaticArguments(argumentList, element,
+          callStructure, arguments);
+      return irBuilder.buildStaticFunctionInvocation(
+          element,
+          callStructure,
+          arguments,
           sourceInformation:
-                sourceInformationBuilder.buildCall(node, node.selector));
+              sourceInformationBuilder.buildCall(node, node.selector));
     }
 
     /// Lookup the value of the enum described by [node].
     getEnumValue(ast.Node node, EnumClassElement enumClass, List values) {
       Element element = elements[node];
       if (element is! FieldElement || element.enclosingClass != enumClass) {
         internalError(node, 'expected a JsBuiltin enum value');
       }
 
       int index = enumClass.enumValues.indexOf(element);
@@ skipping 169 matching lines @@
 
       default:
         giveup(node, 'unplemented native construct: ${function.name}');
         break;
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(ast.Send node,
                                           MethodElement function,
-                                          ast.NodeList argumentList,
+                                          ast.NodeList argumentsNode,
                                           CallStructure callStructure,
                                           _) {
     if (compiler.backend.isForeign(function)) {
-      return handleForeignCode(node, function, argumentList, callStructure);
+      return handleForeignCode(node, function, argumentsNode, callStructure);
     } else {
-      return irBuilder.buildStaticFunctionInvocation(function, callStructure,
-          translateStaticArguments(argumentList, function, callStructure),
+      List<ir.Primitive> arguments = <ir.Primitive>[];
+      callStructure = translateStaticArguments(argumentsNode, function,
+          callStructure, arguments);
+      return irBuilder.buildStaticFunctionInvocation(function,
+          callStructure,
+          arguments,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }