Revert "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 126 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 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);
+    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);
+    }
   }
 
   /// 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 = node.arguments.mapToList(visit);
-    arguments = normalizeDynamicArguments(selector, arguments);
+    List<ir.Primitive> arguments = new List<ir.Primitive>();
+    for (ast.Node n in node.arguments) {
+      arguments.add(visit(n));
+    }
     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);
     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 = node.arguments.mapToList(visit);
-      arguments = normalizeStaticArguments(selector, target, arguments);
+      List<ir.Primitive> arguments = new List<ir.Primitive>();
+      for (ast.Node n in node.arguments) {
+        arguments.add(visit(n));
+      }
       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.Primitive> arguments =
+    List<ir.Definition> 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) {
+  ir.Primitive translateConstant(ast.Node node, [ConstantExpression constant]) {
     assert(irBuilder.isOpen);
-    return irBuilder.buildConstantLiteral(getConstantForNode(node));
+    if (constant == null) {
+      constant = getConstantForNode(node);
+    }
+    return irBuilder.buildConstantLiteral(constant);
   }
 
   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;
-  }
-
 }