Revert "dart2js cps: Refactor and optimize string concatenations."

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 249 matching lines @@
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitInvokeConstructor(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeConstructor(this, arg);
   }
 }
 
+/// Calls [toString] on each argument and concatenates the results.
+class ConcatenateStrings extends Expression {
+  final List<Expression> arguments;
+
+  ConcatenateStrings(this.arguments);
+
+  accept(ExpressionVisitor visitor) => visitor.visitConcatenateStrings(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitConcatenateStrings(this, arg);
+  }
+}
+
 /**
  * A constant.
  */
 class Constant extends Expression {
+  final ConstantExpression expression;
   final values.ConstantValue value;
 
-  Constant(this.value);
+  Constant(this.expression, this.value);
 
   Constant.bool(values.BoolConstantValue constantValue)
-      : value = constantValue;
+      : expression = new BoolConstantExpression(
+          constantValue.primitiveValue),
+        value = constantValue;
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitConstant(this, arg);
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitThis(this, arg);
 }
 
@@ skipping 546 matching lines @@
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression node) => node.accept(this);
   E visitVariableUse(VariableUse node);
   E visitAssign(Assign node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
+  E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitGetField(GetField node);
@@ skipping 11 matching lines @@
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression node, A arg) => node.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
   E visitAssign(Assign node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
+  E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
   E visitGetField(GetField node, A arg);
@@ skipping 72 matching lines @@
 
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitExpression);
   }
 
+  visitConcatenateStrings(ConcatenateStrings node) {
+    node.arguments.forEach(visitExpression);
+  }
+
   visitConstant(Constant node) {}
 
   visitThis(This node) {}
 
   visitConditional(Conditional node) {
     visitExpression(node.condition);
     visitExpression(node.thenExpression);
     visitExpression(node.elseExpression);
   }
 
@@ skipping 165 matching lines @@
     node.receiver = visitExpression(node.receiver);
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitInvokeConstructor(InvokeConstructor node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
+  visitConcatenateStrings(ConcatenateStrings node) {
+    _replaceExpressions(node.arguments);
+    return node;
+  }
+
   visitConstant(Constant node) => node;
 
   visitThis(This node) => node;
 
   visitConditional(Conditional node) {
     node.condition = visitExpression(node.condition);
     node.thenExpression = visitExpression(node.thenExpression);
     node.elseExpression = visitExpression(node.elseExpression);
     return node;
   }
@@ skipping 143 matching lines @@
 
   visitUnreachable(Unreachable node) {
     return node;
   }
 
   visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }