dart2dart: Support for all constants 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,
          ClassElement;
@@ skipping 118 matching lines @@
   final List<Expression> arguments;
 
   InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 /**
  * Non-const call to a factory or generative constructor.

[sigurdm, 2014/06/23 07:22:20]

Comment is out-of-sync  with reality

[asgerf, 2014/06/23 07:28:27]

Thanks

  */
 class InvokeConstructor extends Expression implements Invoke {
   final GenericType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
+  final dart2js.Constant constant;
 
-  InvokeConstructor(this.type, this.target, this.selector, this.arguments);
+  InvokeConstructor(this.type, this.target, this.selector, this.arguments,
+      [this.constant]);
 
   ClassElement get targetClass => target.enclosingElement;
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// Calls [toString] on each argument and concatenates the results.
 class ConcatenateStrings extends Expression {
   final List<Expression> arguments;
+  final dart2js.Constant constant;
 
-  ConcatenateStrings(this.arguments);
+  ConcatenateStrings(this.arguments, [this.constant]);
 
   accept(ExpressionVisitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
 /**
  * A constant.
  */
 class Constant extends Expression {
   dart2js.Constant value;
 
   Constant(this.value);
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
 }
 
 class LiteralList extends Expression {
+  final GenericType type;
   final List<Expression> values;
+  final dart2js.Constant constant;
 
-  LiteralList(this.values) ;
+  LiteralList(this.type, this.values, [this.constant]);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMap extends Expression {
+  final GenericType type;
   final List<Expression> keys;
   final List<Expression> values;
+  final dart2js.Constant constant;
 
-  LiteralMap(this.keys, this.values) ;
+  LiteralMap(this.type, this.keys, this.values, [this.constant]);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
 }
 
-class InvokeConstConstructor extends Expression implements Invoke {
-  final GenericType type;
-  final FunctionElement target;
-  final List<Expression> arguments;
-  final Selector selector;
-
-  ClassElement get targetClass => target.enclosingElement;
-
-  InvokeConstConstructor(this.type, this.target, this.selector, this.arguments);
-
-  accept(ExpressionVisitor visitor) => visitor.visitInvokeConstConstructor(this);
-}
-
 /// A conditional expression.
 class Conditional extends Expression {
   Expression condition;
   Expression thenExpression;
   Expression elseExpression;
 
   Conditional(this.condition, this.thenExpression, this.elseExpression);
 
   accept(ExpressionVisitor visitor) => visitor.visitConditional(this);
 }
@@ skipping 211 matching lines @@
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
-  E visitInvokeConstConstructor(InvokeConstConstructor node);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
@@ skipping 213 matching lines @@
     for (ir.Parameter p in node.parameters) {
       Variable parameter = getVariable(p);
       assert(parameter != null);
       parameters.add(parameter);
     }
     function = new FunctionDefinition(parameters, visit(node.body));
     return null;
   }
 
   Statement visitLetPrim(ir.LetPrim node) {
-    // LetPrim is translated to Assign.
-    Expression definition = visit(node.primitive);
     Variable variable = getVariable(node.primitive);
-    if (variable != null) { // Variable is null if primitive is unused.
-      return new Assign(variable, definition, visit(node.body));
-    } else if (node.primitive is ir.Constant) {
-      // TODO(kmillikin): Implement more systematic treatment of pure CPS
-      // values (e.g., as part of a shrinking reductions pass).
-      return visit(node.body);
-    } else {
-      return new ExpressionStatement(definition, visit(node.body));
-    }
+    return variable == null
+        ? visit(node.body)
+        : new Assign(variable, visit(node.primitive), visit(node.body));
   }
 
   Statement visitLetCont(ir.LetCont node) {
     Label label;
     if (node.continuation.hasMultipleUses) {
       label = new Label();
       labels[node.continuation] = label;
     }
     Statement body = visit(node.body);
     // The continuation's body is not always translated directly here because
@@ skipping 113 matching lines @@
     thenStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     cont = node.falseContinuation.definition;
     assert(cont.parameters.isEmpty);
     elseStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
   Expression visitInvokeConstConstructor(ir.InvokeConstConstructor node) {
-    return new InvokeConstConstructor(node.type, node.constructor, node.selector,
-        translateArguments(node.arguments));
+    return new InvokeConstructor(
+        node.type,
+        node.constructor,
+        node.selector,
+        translateArguments(node.arguments),
+        node.constant);
   }
 
   Expression visitConstant(ir.Constant node) {
     return new Constant(node.value);
   }
 
   Expression visitLiteralList(ir.LiteralList node) {
-    return new LiteralList(translateArguments(node.values));
+    return new LiteralList(
+            node.type,
+            translateArguments(node.values),
+            node.constant);
   }
 
   Expression visitLiteralMap(ir.LiteralMap node) {
     return new LiteralMap(
+        node.type,
         translateArguments(node.keys),
-        translateArguments(node.values));
+        translateArguments(node.values),
+        node.constant);
   }
 
   Expression visitParameter(ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
     compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
     return null;
   }
 
   Expression visitContinuation(ir.Continuation node) {
@@ skipping 170 matching lines @@
     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;
   }
 
-  Expression visitInvokeConstConstructor(InvokeConstConstructor node) {
-    for (int i = node.arguments.length - 1; i >= 0; --i) {
-      node.arguments[i] = visitExpression(node.arguments[i]);
-    }
-    return node;
-  }
-
   Expression visitConcatenateStrings(ConcatenateStrings node) {
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
     return node;
   }
 
   Expression visitConditional(Conditional node) {
     node.condition = visitExpression(node.condition);
 
@@ skipping 696 matching lines @@
     if (node.condition is Not) {
       node.condition = (node.condition as Not).operand;
       Expression tmp = node.thenExpression;
       node.thenExpression = node.elseExpression;
       node.elseExpression = tmp;
     }
 
     return node;
   }
 
-  Expression visitInvokeConstConstructor(InvokeConstConstructor node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
-
   Expression visitLogicalOperator(LogicalOperator node) {
     node.left = makeCondition(node.left, true);
     node.right = makeCondition(node.right, true);
     return node;
   }
 
   /// True if the given expression is known to evaluate to a boolean.
   /// This will not recursively traverse [Conditional] expressions, but if
   /// applied to the result of [visitExpression] conditionals will have been
   /// rewritten anyway.
@@ skipping 137 matching lines @@
     }
   }
 
   /// Destructively updates each entry of [l] with the result of visiting it.
   void _rewriteList(List<Expression> l) {
     for (int i = 0; i < l.length; i++) {
       l[i] = visitExpression(l[i]);
     }
   }
 }