Handle named and optional arguments in cps-ir.

pkg/compiler/lib/src/ssa/builder.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 SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 1101 matching lines @@
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
 
     bool isInstanceMember = function.isInstanceMember;
     // For static calls, [providedArguments] is complete, default arguments
-    // have been included if necessary, see [addStaticSendArgumentsToList].
+    // have been included if necessary, see [makeStaticArgumentList].
     if (!isInstanceMember
         || currentNode == null // In erroneous code, currentNode can be null.
         || providedArgumentsKnownToBeComplete(currentNode)
         || function.isGenerativeConstructorBody
         || selector.isGetter) {
       // For these cases, the provided argument list is known to be complete.
       return providedArguments;
     } else {
       return completeDynamicSendArgumentsList(
           selector, function, providedArguments);
@@ skipping 707 matching lines @@
         assert(link.head is ast.Send);
         if (link.head is !ast.SendSet) {
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
                  ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
           Selector selector = elements.getSelector(call);
           Link<ast.Node> arguments = call.arguments;
-          List<HInstruction> compiledArguments = new List<HInstruction>();
+          List<HInstruction> compiledArguments;
           inlinedFrom(constructor, () {
-            addStaticSendArgumentsToList(selector,
-                                         arguments,
-                                         target,
-                                         compiledArguments);
+            compiledArguments =
+                makeStaticArgumentList(selector, arguments, target);
           });
           inlineSuperOrRedirect(target,
                                 compiledArguments,
                                 constructors,
                                 fieldValues,
                                 constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
@@ skipping 15 matching lines @@
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
             new Selector.callDefaultConstructor(enclosingClass.library);
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError(superClass,
               "No default constructor available.");
         }
-        List<HInstruction> arguments = <HInstruction>[];
-        selector.addArgumentsToList(const Link<ast.Node>(),
-                                    arguments,
-                                    target.implementation,
-                                    null,
-                                    handleConstantForOptionalParameter,
-                                    compiler.world);
+        List<HInstruction> arguments =
+            selector.makeArgumentsList2(const Link<ast.Node>(),
+                                        target.implementation,
+                                        null,
+                                        handleConstantForOptionalParameter);
         inlineSuperOrRedirect(target,
                               arguments,
                               constructors,
                               fieldValues,
                               constructor);
       }
     }
   }
 
   /**
@@ skipping 1534 matching lines @@
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
       List<String> orderedNames = selector.getOrderedNamedArguments();
       for (String name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
   /**
-   * Returns true if the arguments were compatible with the function signature.
+   * Returns a list with the evaluated [arguments] in the normalized order.
    *
+   * Precondition: `this.applies(element, world)`.
    * Invariant: [element] must be an implementation element.
    */
-  bool addStaticSendArgumentsToList(Selector selector,
-                                    Link<ast.Node> arguments,
-                                    FunctionElement element,
-                                    List<HInstruction> list) {
+  List<HInstruction> makeStaticArgumentList(Selector selector,
+                                            Link<ast.Node> arguments,
+                                            FunctionElement element) {
     assert(invariant(element, element.isImplementation));
 
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
-    return selector.addArgumentsToList(arguments,
-                                       list,
+    return selector.makeArgumentsList2(arguments,
                                        element,
                                        compileArgument,
-                                       handleConstantForOptionalParameter,
-                                       compiler.world);
+                                       handleConstantForOptionalParameter);
   }
 
   void addGenericSendArgumentsToList(Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   visitDynamicSend(ast.Send node) {
@@ skipping 491 matching lines @@
         addGenericSendArgumentsToList(node.arguments, arguments);
       }
       return generateSuperNoSuchMethodSend(node, selector, arguments);
     }
     List<HInstruction> inputs = <HInstruction>[];
     if (node.isPropertyAccess) {
       push(buildInvokeSuper(selector, element, inputs));
     } else if (element.isFunction || element.isGenerativeConstructor) {
       if (selector.applies(element, compiler.world)) {
         // TODO(5347): Try to avoid the need for calling [implementation] before
-        // calling [addStaticSendArgumentsToList].
+        // calling [makeStaticArgumentList].
         FunctionElement function = element.implementation;
-        bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                      function, inputs);
-        assert(succeeded);
+        assert(selector.applies(function, compiler.world));
+        inputs = makeStaticArgumentList(selector,
+                                        node.arguments,
+                                        function);
         push(buildInvokeSuper(selector, element, inputs));
       } else if (element.isGenerativeConstructor) {
         generateWrongArgumentCountError(node, element, node.arguments);
       } else {
         addGenericSendArgumentsToList(node.arguments, inputs);
         generateSuperNoSuchMethodSend(node, selector, inputs);
       }
     } else {
       HInstruction target = buildInvokeSuper(selector, element, inputs);
       add(target);
@@ skipping 257 matching lines @@
 
     if (checkTypeVariableBounds(node, type)) return;
 
     var inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         Elements.isNativeOrExtendsNative(constructor.enclosingClass)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
     // TODO(5347): Try to avoid the need for calling [implementation] before
-    // calling [addStaticSendArgumentsToList].
-    bool succeeded = addStaticSendArgumentsToList(selector, send.arguments,
-                                                  constructor.implementation,
-                                                  inputs);
-    if (!succeeded) {
+    // calling [makeStaticArgumentList].
+    if (!selector.applies(constructor.implementation, compiler.world)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
+    inputs.addAll(makeStaticArgumentList(selector,
+                                         send.arguments,
+                                         constructor.implementation));
 
     if (constructor.isFactoryConstructor &&
         !expectedType.typeArguments.isEmpty) {
       registry.registerFactoryWithTypeArguments();
     }
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(compiler)) {
         HTypeConversion conversion = new HTypeConversion(
@@ skipping 161 matching lines @@
       // An erroneous element indicates that the funciton could not be resolved
       // (a warning has been issued).
       generateThrowNoSuchMethod(node,
                                 noSuchMethodTargetSymbolString(element),
                                 argumentNodes: node.arguments);
       return;
     }
     invariant(element, !element.isGenerativeConstructor);
     generateIsDeferredLoadedCheckIfNeeded(node);
     if (element.isFunction) {
-      var inputs = <HInstruction>[];
       // TODO(5347): Try to avoid the need for calling [implementation] before
-      // calling [addStaticSendArgumentsToList].
-      bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                    element.implementation,
-                                                    inputs);
-      if (!succeeded) {
+      // calling [makeStaticArgumentList].
+      if (!selector.applies(element.implementation, compiler.world)) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
+      List<HInstruction> inputs =
+          makeStaticArgumentList(selector,
+                                 node.arguments,
+                                 element.implementation);
+
       if (element == compiler.identicalFunction) {
         pushWithPosition(
             new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
         return;
       }
 
       pushInvokeStatic(node, element, inputs);
     } else {
       generateGetter(node, element);
       List<HInstruction> inputs = <HInstruction>[pop()];
@@ skipping 2134 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }