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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 418 matching lines @@
            this.type,
            List<Primitive> typeArguments,
            Continuation cont)
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments),
         this.continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitTypeCast(this);
 }
 
+/// Invoke [toString] on each argument and concatenate the results.
+class ConcatenateStrings extends Expression {
+  final List<Reference<Primitive>> arguments;
+  final Reference<Continuation> continuation;
+
+  ConcatenateStrings(List<Primitive> args, Continuation cont)
+      : arguments = _referenceList(args),
+        continuation = new Reference<Continuation>(cont);
+
+  accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
+}
+
 /// Apply a built-in operator.
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinOperator extends Primitive {
   BuiltinOperator operator;
   List<Reference<Primitive>> arguments;
 
   ApplyBuiltinOperator(this.operator, List<Primitive> arguments)
       : this.arguments = _referenceList(arguments);
 
@@ skipping 301 matching lines @@
   ForeignCode(this.codeTemplate, this.type, List<Primitive> arguments,
       this.nativeBehavior, {Continuation continuation, this.dependency})
       : arguments = _referenceList(arguments),
         continuation = continuation == null ? null
             : new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 }
 
 class Constant extends Primitive {
+  final ConstantExpression expression;
   final values.ConstantValue value;
 
-  Constant(this.value);
+  Constant(this.expression, this.value);
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final InterfaceType type;
   final List<Reference<Primitive>> values;
 
   LiteralList(this.type, List<Primitive> values)
@@ skipping 173 matching lines @@
   // Expressions.
   T visitLetPrim(LetPrim node);
   T visitLetCont(LetCont node);
   T visitLetHandler(LetHandler node);
   T visitLetMutable(LetMutable node);
   T visitInvokeContinuation(InvokeContinuation node);
   T visitInvokeStatic(InvokeStatic node);
   T visitInvokeMethod(InvokeMethod node);
   T visitInvokeMethodDirectly(InvokeMethodDirectly node);
   T visitInvokeConstructor(InvokeConstructor node);
+  T visitConcatenateStrings(ConcatenateStrings node);
   T visitThrow(Throw node);
   T visitRethrow(Rethrow node);
   T visitBranch(Branch node);
   T visitTypeCast(TypeCast node);
   T visitSetMutableVariable(SetMutableVariable node);
   T visitSetStatic(SetStatic node);
   T visitGetLazyStatic(GetLazyStatic node);
   T visitSetField(SetField node);
   T visitUnreachable(Unreachable node);
 
@@ skipping 106 matching lines @@
     node.arguments.forEach(processReference);
   }
 
   processInvokeConstructor(InvokeConstructor node) {}
   visitInvokeConstructor(InvokeConstructor node) {
     processInvokeConstructor(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
+  processConcatenateStrings(ConcatenateStrings node) {}
+  visitConcatenateStrings(ConcatenateStrings node) {
+    processConcatenateStrings(node);
+    processReference(node.continuation);
+    node.arguments.forEach(processReference);
+  }
+
   processThrow(Throw node) {}
   visitThrow(Throw node) {
     processThrow(node);
     processReference(node.value);
   }
 
   processRethrow(Rethrow node) {}
   visitRethrow(Rethrow node) {
     processRethrow(node);
   }
@@ skipping 197 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }