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 382 matching lines @@
     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);
+    CallStructure normalizedCallStructure =
+        normalizeDynamicArguments(callStructure, arguments);
     return irBuilder.buildCallInvocation(
-        receiver, callStructure, arguments,
+        receiver, normalizedCallStructure, 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 210 matching lines @@
     return irBuilder.buildNegation(check);
   }
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
     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, _) {
     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,
                                    CallStructure callStructure,
                                    SourceInformation sourceInformation) {
-
-    return irBuilder.buildCallInvocation(target, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildCallInvocation(target, normalizedCallStructure,
+        normalizedArguments,
         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,
       Selector selector,
       _) {
+    ir.Primitive target = translateReceiver(receiver);
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, selector.callStructure, normalizedArguments);
     return irBuilder.buildDynamicInvocation(
-        translateReceiver(receiver), selector, elements.getTypeMask(node),
-        translateDynamicArguments(arguments, selector.callStructure),
+        target,
+        new Selector(selector.kind, selector.memberName,
+            normalizedCallStructure),
+        elements.getTypeMask(node),
+        normalizedArguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       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> normalizedArguments = <ir.Primitive>[];
+          CallStructure normalizedCallStructure = translateDynamicArguments(
+              arguments, selector.callStructure, normalizedArguments);
+          return irBuilder.buildDynamicInvocation(
+              target,
+              new Selector(selector.kind, selector.memberName,
+                  normalizedCallStructure),
+              elements.getTypeMask(node),
+              normalizedArguments);
+        }));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalVariableInvocation(element, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildLocalVariableInvocation(
+        element,
+        normalizedCallStructure,
+        normalizedArguments,
         callSourceInformation:
             sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildLocalFunctionInvocation(function, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildLocalFunctionInvocation(
+        function,
+        normalizedCallStructure,
+        normalizedArguments,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @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,
       CallStructure callStructure,
       _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     ir.Primitive target = buildStaticFieldGet(field, src);
-    return irBuilder.buildCallInvocation(target,
-        callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildCallInvocation(
+        target,
+        normalizedCallStructure,
+        normalizedArguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
@@ skipping 12 matching lines @@
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildStaticGetterGet(
         getter, sourceInformationBuilder.buildGet(node));
-    return irBuilder.buildCallInvocation(target,
-        callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildCallInvocation(
+        target,
+        normalizedCallStructure,
+        normalizedArguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildSuperFieldGet(field);
-    return irBuilder.buildCallInvocation(target,
-        callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildCallInvocation(
+        target,
+        normalizedCallStructure,
+        normalizedArguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ir.Primitive target = irBuilder.buildSuperGetterGet(
         getter, sourceInformationBuilder.buildGet(node));
-    return irBuilder.buildCallInvocation(target,
-        callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildCallInvocation(
+        target,
+        normalizedCallStructure,
+        normalizedArguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    return irBuilder.buildSuperMethodInvocation(method, callStructure,
-        translateDynamicArguments(arguments, callStructure),
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
+    return irBuilder.buildSuperMethodInvocation(
+        method,
+        normalizedCallStructure,
+        normalizedArguments,
         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>[];
+    translateDynamicArguments(arguments, callStructure, normalizedArguments);
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not obvious whether this selector should match the normalized arguments or
not.

[Johnni Winther, 2015/12/03 12:15:42]

We should. Create the new selector by:

CallStructure callStructure = translateDyn...
Selector selector = new Selector.call(method.memberName, callStructure);

[Kevin Millikin (Google), 2015/12/09 12:49:13]

Done.

         elements.getTypeMask(node),
-        translateDynamicArguments(arguments, callStructure));
+        normalizedArguments);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    translateDynamicArguments(arguments, selector.callStructure,
+        normalizedArguments);
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not obvious whether this selector should match the normalized arguments or
not.

[Johnni Winther, 2015/12/03 12:15:42]

Also here. Obtain the member name from `elements.getSelector(node).memberName`
and a TODO for to supply a [Name] in the visitor.

[Kevin Millikin (Google), 2015/12/09 12:49:13]

Done.

         elements.getTypeMask(node),
-        translateDynamicArguments(arguments, selector.callStructure));
+        normalizedArguments);
   }
 
   @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 128 matching lines @@
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList arguments,
       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> normalizedArguments = <ir.Primitive>[];
+    translateDynamicArguments(arguments, selector.callStructure,
+        normalizedArguments);
+    return buildStaticNoSuchMethod(selector, normalizedArguments);

[Kevin Millikin (Google), 2015/12/02 15:45:31]

This selector doesn't seem to matter because it looks like only the name is
used.

It's not clear if it should match the normalized arguments or not, or if we
care.

[Johnni Winther, 2015/12/03 12:15:42]

Similar to the super-cases above. We should normalize but we need a [Name].
Generally [buildStaticNoSuchMethod] shouldn't really use [Selector].

[Kevin Millikin (Google), 2015/12/09 12:49:13]

Done.

   }
 
   @override
   ir.Primitive visitConstructorIncompatibleInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    translateDynamicArguments(arguments, callStructure, normalizedArguments);
     return buildStaticNoSuchMethod(elements.getSelector(node.send),

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not clear if this selector should match the normalized arguments or not.

-        translateDynamicArguments(arguments, callStructure));
+        normalizedArguments);
   }
 
   @override
   ir.Primitive visitUnresolvedGet(
       ast.Send node,
       Element element, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), []);

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not clear if this selector should match the normalized arguments or not.

   }
 
   @override
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node),

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not clear if this selector should match the normalized arguments or not.

         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
        ConstructorElement constructor,
        InterfaceType type,
        ast.NodeList arguments,
        CallStructure callStructure, _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
     return buildStaticNoSuchMethod(

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not clear if this selector should match the normalized arguments or not. 
Here it does.  At the other call sites for buildStaticNoSuchMethod it does not.

-        new Selector.call(name, callStructure),
-        translateDynamicArguments(arguments, callStructure));
+        new Selector.call(name, normalizedCallStructure),
+        normalizedArguments);
   }
 
   @override
   ir.Primitive visitUnresolvedSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not clear if this selector should match the normalized arguments or not.

   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndex(
       ast.Send node,
       Element function,
       ast.Node index, _) {
     // Assume the index getter is missing.
     return buildInstanceNoSuchMethod(
         new Selector.index(), elements.getTypeMask(node), [visit(index)]);
@@ skipping 192 matching lines @@
         elements.getTypeMask(node),
         []);
   }
 
   @override
   ir.Primitive visitSuperSetterInvoke(
       ast.Send node,
       SetterElement setter,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
-    List<ir.Primitive> args =
-        translateDynamicArguments(arguments, callStructure);
+    List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
     return buildInstanceNoSuchMethod(
-        new Selector.call(setter.memberName, callStructure),
+        new Selector.call(setter.memberName, normalizedCallStructure),

[Kevin Millikin (Google), 2015/12/02 15:45:31]

It's not obvious if this selector should match the normalized arguments or not. 
Here it does (at the other two call sites for buildInstanceNoSuchMethod it does
not).

Apparently, we don't have tests that care.

         elements.getTypeMask(node),
-        args);
+        normalizedArguments);
   }
 
   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,
       CallStructure callStructure,
       _) {
-    List<ir.Primitive> arguments =
-        node.send.arguments.mapToList(visit, growable:false);
+    List<ir.Primitive> arguments = node.send.arguments.mapToList(visit);
     // Use default values from the effective target, not the immediate target.
     ConstructorElement target = constructor.effectiveTarget;
-    arguments = normalizeStaticArguments(callStructure, target, arguments);
+    CallStructure normalizedCallStructure =
+        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,
-        callStructure,
+        normalizedCallStructure,
         constructor.computeEffectiveTargetType(type),
         arguments,
         sourceInformationBuilder.buildNew(node),
         allocationSiteType: allocationSiteType);
   }
 
   @override
   ir.Primitive buildStaticNoSuchMethod(Selector selector,
                                        List<ir.Primitive> arguments) {
     Element thrower = backend.helpers.throwNoSuchMethod;
@@ skipping 79 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> normalizedArguments = <ir.Primitive>[];
+      CallStructure normalizedCallStructure = translateStaticArguments(
+          argumentList, element, callStructure, normalizedArguments);
+      return irBuilder.buildStaticFunctionInvocation(
+          element,
+          normalizedCallStructure,
+          normalizedArguments,
           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 175 matching lines @@
 
   @override
   ir.Primitive handleStaticFunctionInvoke(ast.Send node,
                                           MethodElement function,
                                           ast.NodeList argumentList,
                                           CallStructure callStructure,
                                           _) {
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
-      return irBuilder.buildStaticFunctionInvocation(function, callStructure,
-          translateStaticArguments(argumentList, function, callStructure),
+      List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
+      CallStructure normalizedCallStructure = translateStaticArguments(
+          argumentList, function, callStructure, normalizedArguments);
+      return irBuilder.buildStaticFunctionInvocation(function,
+          normalizedCallStructure,
+          normalizedArguments,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }