dart2js cps: Handle optional parameters in builder.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 131 matching lines @@
   /**
    * Builds the [ir.ExecutableDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
   ir.ExecutableDefinition buildExecutable(ExecutableElement element);
 
   ClosureScope getClosureScopeForNode(ast.Node node);
   ClosureEnvironment getClosureEnvironment();
 
+  /// Normalizes the argument list to a static invocation (i.e. where the target
+  /// element is known).
+  ///
+  /// For the JS backend, inserts default arguments and normalizes order of
+  /// named arguments.
+  ///
+  /// For the Dart backend, returns [arguments].
+  List<ir.Primitive> normalizeStaticArguments(
+      Selector selector,
+      FunctionElement target,
+      List<ir.Primitive> arguments);
 
+  /// Normalizes the argument list of a dynamic invocation (i.e. where the
+  /// target element is unknown).
+  ///
+  /// For the JS backend, normalizes order of named arguments.
+  ///
+  /// For the Dart backend, returns [arguments].
+  List<ir.Primitive> normalizeDynamicArguments(
+      Selector selector,
+      List<ir.Primitive> arguments);
 
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<ParameterElement> parameters = [];
     signature.orderedForEachParameter(parameters.add);
 
     irBuilder.buildFunctionHeader(parameters,
                                   closureScope: getClosureScopeForNode(node),
                                   env: getClosureEnvironment());
@@ skipping 384 matching lines @@
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   ir.Primitive visitClosureSend(ast.Send node) {
     assert(irBuilder.isOpen);
     Element element = elements[node];
-    Selector closureSelector = elements.getSelector(node);
-    if (element == null) {
-      ir.Primitive closureTarget = visit(node.selector);
-      List<ir.Primitive> args =
-          node.arguments.mapToList(visit, growable:false);
-      return irBuilder.buildFunctionExpressionInvocation(
-          closureTarget, elements.getSelector(node), args);
-    } else {
-      List<ir.Primitive> args =
-          node.arguments.mapToList(visit, growable:false);
-      return irBuilder.buildLocalInvocation(
-          element, elements.getSelector(node), args);
-    }
+    Selector selector = elements.getSelector(node);
+    ir.Primitive receiver = (element == null)
+        ? visit(node.selector)
+        : irBuilder.buildLocalGet(element);
+    List<ir.Primitive> arguments = node.arguments.mapToList(visit);
+    arguments = normalizeDynamicArguments(selector, arguments);
+    return irBuilder.buildFunctionExpressionInvocation(
+        receiver, selector, arguments);
   }
 
   /// If [node] is null, returns this.
   /// If [node] is super, returns null (for special handling)
   /// Otherwise visits [node] and returns the result.
   ir.Primitive visitReceiver(ast.Expression node) {
     if (node == null) return irBuilder.buildThis();
     if (node.isSuper()) return null;
     return visit(node);
   }
 
   /// 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();
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(irBuilder.isOpen);
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visitReceiver(node.receiver);
-    List<ir.Primitive> arguments = new List<ir.Primitive>();
-    for (ast.Node n in node.arguments) {
-      arguments.add(visit(n));
-    }
+    List<ir.Primitive> arguments = node.arguments.mapToList(visit);
+    arguments = normalizeDynamicArguments(selector, arguments);
     return irBuilder.buildDynamicInvocation(receiver, selector, arguments);
   }
 
   _GetterElements translateGetter(ast.Send node, Selector selector) {
     Element element = elements[node];
     ir.Primitive result;
     ir.Primitive receiver;
     ir.Primitive index;
 
     if (element != null && element.isConst) {
@@ skipping 105 matching lines @@
     assert(irBuilder.isOpen);
     Element element = elements[node];
     assert(!element.isConstructor);
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler.backend)) {
       return giveup(node, 'StaticSend: foreign');
     }
 
     Selector selector = elements.getSelector(node);
 
-    // TODO(lry): support default arguments, need support for locals.
     List<ir.Primitive> arguments =
         node.arguments.mapToList(visit, growable:false);
+    arguments = normalizeStaticArguments(selector, element, arguments);

[asgerf, 2015/02/11 10:31:32]

This would fail in checked-mode when the element was not a FunctionElement.

     return irBuilder.buildStaticInvocation(element, selector, arguments);
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(irBuilder.isOpen);
     if (node.isPropertyAccess) {
       return visitGetterSend(node);
     } else {
       Selector selector = elements.getSelector(node);
       Element target = elements[node];
-      List<ir.Primitive> arguments = new List<ir.Primitive>();
-      for (ast.Node n in node.arguments) {
-        arguments.add(visit(n));
-      }
+      List<ir.Primitive> arguments = node.arguments.mapToList(visit);
+      arguments = normalizeStaticArguments(selector, target, arguments);
       return irBuilder.buildSuperInvocation(target, selector, arguments);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
     assert(irBuilder.isOpen);
@@ skipping 112 matching lines @@
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
     if (node.isConst) {
       return translateConstant(node);
     }
     FunctionElement element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     DartType type = elements.getType(node);
     ast.Node selectorNode = node.send.selector;
-    List<ir.Definition> arguments =
+    List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
+    arguments = normalizeStaticArguments(selector, element, arguments);
     return irBuilder.buildConstructorInvocation(
         element, selector, type, arguments);
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     return irBuilder.buildStringConcatenation([first, second]);
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> arguments = [];
     arguments.add(visitLiteralString(node.string));
     var it = node.parts.iterator;
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
     return irBuilder.buildStringConcatenation(arguments);
   }
 
-  ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
+  ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    if (constant == null) {
-      constant = getConstantForNode(node);
-    }
-    return irBuilder.buildConstantLiteral(constant);
+    return irBuilder.buildConstantLiteral(getConstantForNode(node));
   }
 
   ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
@@ skipping 194 matching lines @@
       SynthesizedConstructorElementX constructor = element;
       if (!constructor.isDefaultConstructor) {
         giveup(null, 'cannot handle synthetic forwarding constructors');
       }
     }
 
     IrBuilder builder = makeIRBuilder(node, element);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
+
+  List<ir.Primitive> normalizeStaticArguments(
+      Selector selector,
+      FunctionElement target,
+      List<ir.Primitive> arguments) {
+    return arguments;
+  }
+
+  List<ir.Primitive> normalizeDynamicArguments(
+      Selector selector,
+      List<ir.Primitive> arguments) {
+    return arguments;
+  }
 }
 
 /// IR builder specific to the JavaScript backend, coupled to the [JsIrBuilder].
 class JsIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [JsIrBuilder].
   JsIrBuilder get irBuilder => super.irBuilder;
 
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
@@ skipping 115 matching lines @@
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
         elementSourceFile(context));
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
   }
 
+  /// Builds the IR for a constant taken from a different [context].
+  ///
+  /// Such constants need to be compiled with a different [sourceFile] and
+  /// [elements] mapping.
+  ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
+    JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
+        context.resolvedAst.elements,
+        compiler,
+        elementSourceFile(context));
+    return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
+  }
+
   /// Builds the IR for a given constructor.
   ///
   /// 1. Evaluates all own or inherited field initializers.
   /// 2. Creates the object and assigns its fields.
   /// 3. Calls constructor body and super constructor bodies.
   /// 4. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
     constructor = constructor.implementation;
     ClassElement classElement = constructor.enclosingClass.implementation;
 
@@ skipping 284 matching lines @@
 
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         element,
         node,
         elements);
     IrBuilder builder =
         new JsIrBuilder(compiler.backend.constantSystem, element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
+  /// Creates a primitive for the default value of [parameter].
+  ir.Primitive translateDefaultValue(ParameterElement parameter) {
+    if (parameter.initializer == null) {
+      return irBuilder.buildNullLiteral();
+    } else {
+      return inlineConstant(parameter.executableContext, parameter.initializer);
+    }
+  }
+
+  /// Inserts default arguments and normalizes order of named arguments.
+  List<ir.Primitive> normalizeStaticArguments(
+      Selector selector,
+      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;
+    }
+
+    List<ir.Primitive> result = <ir.Primitive>[];
+    int i = 0;
+    signature.forEachRequiredParameter((ParameterElement element) {
+      result.add(arguments[i]);
+      ++i;
+    });
+
+    if (!signature.optionalParametersAreNamed) {
+      signature.forEachOptionalParameter((ParameterElement element) {
+        if (i < arguments.length) {
+          result.add(arguments[i]);
+          ++i;
+        } else {
+          result.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 = selector.namedArguments.indexOf(element.name);
+        if (nameIndex != -1) {
+          int translatedIndex = offset + nameIndex;
+          result.add(arguments[translatedIndex]);
+        } else {
+          result.add(translateDefaultValue(element));
+        }
+      });
+    }
+    return result;
+  }
+
+  /// Normalizes order of named arguments.
+  List<ir.Primitive> normalizeDynamicArguments(
+      Selector selector,
+      List<ir.Primitive> arguments) {
+    assert(arguments.length == selector.argumentCount);
+    // Optimization: don't copy the argument list for trivial cases.
+    if (selector.namedArguments.isEmpty) return arguments;
+    List<ir.Primitive> result = <ir.Primitive>[];
+    for (int i=0; i < selector.positionalArgumentCount; i++) {
+      result.add(arguments[i]);
+    }
+    for (String argName in selector.getOrderedNamedArguments()) {
+      int nameIndex = selector.namedArguments.indexOf(argName);
+      int translatedIndex = selector.positionalArgumentCount + nameIndex;
+      result.add(arguments[translatedIndex]);
+    }
+    return result;
+  }
+
 }