dart2dart: Method and constructor calls in new backend.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.dart

 // Copyright (c) 2014, 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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart'
-    show Element, FunctionElement, FunctionSignature, ParameterElement;
+    show Element, FunctionElement, FunctionSignature, ParameterElement,
+         ClassElement;
+import '../universe/universe.dart';
 import '../ir/ir_nodes.dart' as ir;
+import '../tree/tree.dart' as ast;
+import '../scanner/scannerlib.dart';
+import '../dart_types.dart' show DartType, GenericType;
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
 // For that reason, CPS is translated to the direct-style language Tree.
@@ skipping 74 matching lines @@
   final List<Expression> arguments;
 
   InvokeStatic(this.target, this.arguments);
 
   final bool isPure = false;
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 }
 
 /**
+ * A call to a method, operator, getter, setter or index getter/setter.
+ *
+ * In contrast to the CPS-based IR, the receiver and arguments can be
+ * arbitrary expressions.
+ */
+class InvokeMethod extends Expression {
+  Expression receiver;
+  final Selector selector;
+  final List<Expression> arguments;
+
+  InvokeMethod(this.receiver, this.selector, this.arguments) {
+    assert(receiver != null);
+  }
+
+  final bool isPure = false;
+
+  accept(Visitor visitor) => visitor.visitInvokeMethod(this);
+}
+
+/**
+ * Non-const call to a factory or generative constructor.
+ */
+class InvokeConstructor extends Expression {
+  final GenericType type;
+  final FunctionElement target;
+  final List<Expression> arguments;
+
+  InvokeConstructor(this.type, this.target, this.arguments);
+
+  ClassElement get targetClass => target.enclosingElement;
+
+  final bool isPure = false;
+
+  accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
+}
+
+/**
  * A constant.
  */
 class Constant extends Expression {
   final dart2js.Constant value;
 
   Constant(this.value);
 
   final bool isPure = true;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
@@ skipping 91 matching lines @@
   final List<Variable> parameters;
   Statement body;
 
   FunctionDefinition(this.parameters, this.body);
 }
 
 abstract class Visitor<S, E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
+  E visitInvokeMethod(InvokeMethod node);
+  E visitInvokeConstructor(InvokeConstructor node);
   E visitConstant(Constant node);
 
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitIf(If node);
   S visitExpressionStatement(ExpressionStatement node);
 }
@@ skipping 138 matching lines @@
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
       return buildParameterAssignments(cont.parameters, [invoke],
           () => visit(cont.body));
     }
   }
 
+  Statement visitInvokeMethod(ir.InvokeMethod node) {
+    Variable receiver = variables[node.receiver.definition];
+    List<Expression> arguments = translateArguments(node.arguments);
+    Expression invoke = new InvokeMethod(receiver, node.selector, arguments);
+    ir.Continuation cont = node.continuation.definition;
+    if (cont == returnContinuation) {
+      return new Return(invoke);
+    } else {
+      assert(cont.hasExactlyOneUse);
+      assert(cont.parameters.length == 1);
+      return buildParameterAssignments(cont.parameters, [invoke],
+          () => visit(cont.body));
+    }
+  }
+
+  Statement visitInvokeConstructor(ir.InvokeConstructor node) {
+    List<Expression> arguments = translateArguments(node.arguments);
+    Expression invoke = new InvokeConstructor(

[Kevin Millikin (Google), 2014/05/09 11:12:59]

I would break this at = since it is the lowest precedence operator:

Expression invoke =
    new InvokeConstructor(node.type, node.target, arguments);

Or if that doesn't fit, break at the comma not the '(':

Expression invoke = new InvokeConstructor(node.type,
                                          node.target,
                                          arguments);

which uses one fewer line anyway.

+        node.type,
+        node.target,
+        arguments);
+    ir.Continuation cont = node.continuation.definition;
+    if (cont == returnContinuation) {
+      return new Return(invoke);
+    } else {
+      assert(cont.hasExactlyOneUse);
+      assert(cont.parameters.length == 1);
+      return buildParameterAssignments(cont.parameters, [invoke],
+          () => visit(cont.body));
+    }
+  }
+
   Statement visitInvokeContinuation(ir.InvokeContinuation node) {
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       assert(node.arguments.length == 1);
       return new Return(variables[node.arguments[0].definition]);
@@ skipping 138 matching lines @@
   }
 
   Expression visitInvokeStatic(InvokeStatic node) {
     // Process arguments right-to-left, the opposite of evaluation order.
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
     return node;
   }
 
+  Expression visitInvokeMethod(InvokeMethod node) {
+    for (int i = node.arguments.length - 1; i >= 0; --i) {
+      node.arguments[i] = visitExpression(node.arguments[i]);
+    }
+    node.receiver = visitExpression(node.receiver);
+    return node;
+  }
+
+  Expression visitInvokeConstructor(InvokeConstructor node) {
+    for (int i = node.arguments.length - 1; i >= 0; --i) {
+      node.arguments[i] = visitExpression(node.arguments[i]);
+    }
+    return node;
+  }
+
   Statement visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   Statement visitBreak(Break node) {
     return node;
   }
 
   Statement visitIf(If node) {
@@ skipping 12 matching lines @@
     if (!node.expression.isPure) {
       environment.add(null); // insert impurity marker (TODO: refactor)
     }
     node.next = visitStatement(node.next);
     if (!node.expression.isPure) {
       environment.removeLast();
     }
     return node;
   }
 }