dart2js cps: Refactor and optimize string concatenations.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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_builder;
 
 import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
@@ skipping 381 matching lines @@
   final BackendConstantEnvironment constants;
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors = <JumpCollector>[];
 
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors = <JumpCollector>[];
 
-  final List<ConstDeclaration> localConstants = <ConstDeclaration>[];
-
   final ExecutableElement currentElement;
 
   final ir.Continuation returnContinuation = new ir.Continuation.retrn();
   ir.Parameter _thisParameter;
   ir.Parameter enclosingMethodThisParameter;
 
   final List<ir.Parameter> functionParameters = <ir.Parameter>[];
 
   IrBuilderSharedState(this.constants, this.currentElement);
 
@@ skipping 177 matching lines @@
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
     _parameters.add(parameter);
     environment.extend(local, parameter);
     return parameter;
   }
 
-  /// Adds the constant [variableElement] to the environment with [value] as its
-  /// constant value.
-  void declareLocalConstant(LocalVariableElement variableElement,
-                            ConstantExpression value) {
-    state.localConstants.add(new ConstDeclaration(variableElement, value));
-  }
-
   /// Plug an expression into the 'hole' in the context being accumulated.  The
   /// empty context (just a hole) is represented by root (and current) being
   /// null.  Since the hole in the current context is filled by this function,
   /// the new hole must be in the newly added expression---which becomes the
   /// new value of current.
   void add(ir.Expression expr) {
     assert(isOpen);
     if (_root == null) {
       _root = _current = expr;
     } else {
@@ skipping 50 matching lines @@
   ir.Primitive _buildInvokeCall(ir.Primitive target,
                                 CallStructure callStructure,
                                 List<ir.Definition> arguments,
                                 {SourceInformation sourceInformation}) {
     Selector selector = callStructure.callSelector;
     return _buildInvokeDynamic(target, selector, arguments,
         sourceInformation: sourceInformation);
   }
 
 
-  /// Create a [ir.Constant] from [constant] and add it to the CPS term.
-  // TODO(johnniwinther): Remove [value] when [ConstantValue] can be computed
-  // directly from [constant].
-  ir.Constant buildConstant(ConstantExpression constant, ConstantValue value) {
+  /// Create a [ir.Constant] from [value] and add it to the CPS term.
+  ir.Constant buildConstant(ConstantValue value) {
     assert(isOpen);
-    return addPrimitive(new ir.Constant(constant, value));
+    return addPrimitive(new ir.Constant(value));
   }
 
   /// Create an integer constant and add it to the CPS term.
   ir.Constant buildIntegerConstant(int value) {
-    return buildConstant(
-        new IntConstantExpression(value),
-        state.constantSystem.createInt(value));
+    return buildConstant(state.constantSystem.createInt(value));
   }
 
   /// Create a double constant and add it to the CPS term.
   ir.Constant buildDoubleConstant(double value) {
-    return buildConstant(
-        new DoubleConstantExpression(value),
-        state.constantSystem.createDouble(value));
+    return buildConstant(state.constantSystem.createDouble(value));
   }
 
   /// Create a Boolean constant and add it to the CPS term.
   ir.Constant buildBooleanConstant(bool value) {
-    return buildConstant(
-        new BoolConstantExpression(value),
-        state.constantSystem.createBool(value));
+    return buildConstant(state.constantSystem.createBool(value));
   }
 
   /// Create a null constant and add it to the CPS term.
   ir.Constant buildNullConstant() {
-    return buildConstant(
-        new NullConstantExpression(),
-        state.constantSystem.createNull());
+    return buildConstant(state.constantSystem.createNull());
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildStringConstant(String value) {
     return buildConstant(
-        new StringConstantExpression(value),
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildDartStringConstant(ast.DartString value) {
-    return buildConstant(
-        new StringConstantExpression(value.slowToString()),
-        state.constantSystem.createString(value));
+    return buildConstant(state.constantSystem.createString(value));
   }
 
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
   ir.Primitive buildListLiteral(InterfaceType type,
                                 Iterable<ir.Primitive> values) {
     assert(isOpen);
     return addPrimitive(new ir.LiteralList(type, values.toList()));
   }
 
@@ skipping 347 matching lines @@
   }
 
   /// Create a constructor invocation of [element] on [type] where the
   /// constructor name and argument structure are defined by [callStructure] and
   /// the argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
                                           CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments);
 
-  /// Create a string concatenation of the [arguments].
+  ir.Primitive buildStringify(ir.Primitive argument);
+
+  /// Concatenate string values.
+  ///
+  /// The arguments must be strings; usually a call to [buildStringify] is
+  /// needed to ensure the proper conversion takes places.
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
-    return _continueWithExpression(
-        (k) => new ir.ConcatenateStrings(arguments, k));
+    return addPrimitive(new ir.ApplyBuiltinOperator(
+        ir.BuiltinOperator.StringConcatenate,
+        arguments));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the structure of arguments are given by [callStructure].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
       CallStructure callStructure,
       List<ir.Definition> arguments,
       {SourceInformation sourceInformation}) {
     return _buildInvokeCall(functionExpression, callStructure, arguments,
@@ skipping 886 matching lines @@
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
     ir.Constant makeBoolConstant(bool value) {
-      return new ir.Constant(
-          new BoolConstantExpression(value),
-          state.constantSystem.createBool(value));
+      return new ir.Constant(state.constantSystem.createBool(value));
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
         ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
@@ skipping 532 matching lines @@
     ir.Primitive condition = _buildCheckNull(receiver);
     return buildConditional(condition, (_) => receiver, buildSend);
   }
 
   /// Creates a type test checking whether [value] is null.
   ir.Primitive _buildCheckNull(ir.Primitive value) {
     assert(isOpen);
     ir.Primitive right = buildNullConstant();
     return addPrimitive(new ir.Identical(value, right));
   }
+
+  /// Convert the given value to a string.
+  ir.Primitive buildStringify(ir.Primitive value) {
+    return buildStaticFunctionInvocation(
+        program.stringifyFunction,
+        new CallStructure.unnamed(1),
+        <ir.Primitive>[value]);
+  }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 61 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }