dart2js cps: Refactor and optimize string concatenations.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show SynthesizedConstructorElementX,
     ConstructorBodyElementX, FunctionSignatureX;
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/operators.dart' as op;
 import '../tree/tree.dart' as ast;
 import '../universe/universe.dart' show SelectorKind, CallStructure;
+import '../constants/values.dart' show ConstantValue;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder.dart';
 import '../native/native.dart' show NativeBehavior;
 
 // TODO(karlklose): remove.
 import '../js/js.dart' as js show js, Template, Expression;
 import '../ssa/ssa.dart' show TypeMaskFactory;
 import '../types/types.dart' show TypeMask;
 import '../util/util.dart';
 
@@ skipping 315 matching lines @@
         variableElement: variableElement,
         variableSelector: selector,
         buildBody: subbuild(node.body),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(irBuilder.isOpen);
     if (node.modifiers.isConst) {
-      for (ast.SendSet definition in node.definitions.nodes) {
-        assert(!definition.arguments.isEmpty);
-        assert(definition.arguments.tail.isEmpty);
-        VariableElement element = elements[definition];
-        ConstantExpression value = getConstantForVariable(element);
-        irBuilder.declareLocalConstant(element, value);
-      }
+      // Do nothing.
+      // handleLocalConstantGet inlines the constant at use-site.
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
         ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
           assert(definition.arguments.tail.isEmpty);
           initialValue = visit(definition.arguments.head);
@@ skipping 119 matching lines @@
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildNullConstant();
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildDartStringConstant(node.dartString);
   }
 
-  ConstantExpression getConstantForNode(ast.Node node) {
-    ConstantExpression constant =
-        irBuilder.state.constants.getConstantForNode(node, elements);
-    assert(invariant(node, constant != null,
-        message: 'No constant computed for $node'));
-    return constant;
+  ConstantValue getConstantForNode(ast.Node node) {
+    return irBuilder.state.constants.getConstantValueForNode(node, elements);
   }
 
-  ConstantExpression getConstantForVariable(VariableElement element) {
-    ConstantExpression constant =
-        irBuilder.state.constants.getConstantForVariable(element);
-    assert(invariant(element, constant != null,
-            message: 'No constant computed for $element'));
-    return constant;
+  ConstantValue getConstantForVariable(VariableElement element) {
+    return irBuilder.state.constants.getConstantValueForVariable(element);
   }
 
-  /// Builds a constant pulling the value from the constant environment.
-  // TODO(johnniwinther): Remove this when [IrBuilder.buildConstant] only takes
-  // a [ConstantExpression].
-  ir.Primitive buildConstant(ConstantExpression expression) {
-    return irBuilder.buildConstant(expression,
+  ir.Primitive buildConstantExpression(ConstantExpression expression) {
+    return irBuilder.buildConstant(
         irBuilder.state.constants.getConstantValue(expression));
   }
 
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     InterfaceType type = elements.getType(node);
     return irBuilder.buildListLiteral(type, values);
@@ skipping 77 matching lines @@
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
       ast.Node node,
       ConstantExpression constant, _) {
-    return buildConstant(constant);
+    return buildConstantExpression(constant);
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
   ir.Primitive handleDynamicGet(
@@ skipping 16 matching lines @@
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicGet(target, selector)));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
-    return buildConstant(constant);
+    return buildConstantExpression(constant);
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
       ast.Send node,
       LocalVariableElement element,
       _) {
     return element.isConst
-        ? buildConstant(getConstantForVariable(element))
+        ? irBuilder.buildConstant(getConstantForVariable(element))
         : irBuilder.buildLocalVariableGet(element);
   }
 
   @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
     return irBuilder.buildLocalVariableGet(element);
   }
@@ skipping 289 matching lines @@
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = buildConstant(constant);
+    ir.Primitive target = buildConstantExpression(constant);
     return translateCallInvoke(target, arguments, callStructure);
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
@@ skipping 308 matching lines @@
     return irBuilder.buildStaticSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
-        getValue: () => buildConstant(constant),
+        getValue: () => buildConstantExpression(constant),
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.Send node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
@@ skipping 200 matching lines @@
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
           } else {
             buildInstanceNoSuchMethod(
                 new Selector.indexSet(), <ir.Primitive>[indexValue, result]);
           }
         });
   }
 
+  /// Evaluates a string interpolation and appends each part to [accumulator]
+  /// (after stringify conversion).
+  void buildStringParts(ast.Node node, List<ir.Primitive> accumulator) {
+    if (node is ast.StringJuxtaposition) {
+      buildStringParts(node.first, accumulator);
+      buildStringParts(node.second, accumulator);
+    } else if (node is ast.StringInterpolation) {
+      buildStringParts(node.string, accumulator);
+      for (ast.StringInterpolationPart part in node.parts) {
+        buildStringParts(part.expression, accumulator);
+        buildStringParts(part.string, accumulator);
+      }
+    } else if (node is ast.LiteralString) {
+      // Empty strings often occur at the end of a string interpolation,
+      // do not bother to include them.
+      if (!node.dartString.isEmpty) {
+        accumulator.add(irBuilder.buildDartStringConstant(node.dartString));
+      }
+    } else if (node is ast.ParenthesizedExpression) {
+      buildStringParts(node.expression, accumulator);
+    } else {
+      ir.Primitive value = visit(node);
+      accumulator.add(irBuilder.buildStringify(value));
+    }
+  }
+
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
-    ir.Primitive first = visit(node.first);
-    ir.Primitive second = visit(node.second);
-    return irBuilder.buildStringConcatenation([first, second]);
+    List<ir.Primitive> parts = <ir.Primitive>[];
+    buildStringParts(node, parts);
+    return irBuilder.buildStringConcatenation(parts);
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
-    List<ir.Primitive> arguments = [];
-    arguments.add(visitLiteralString(node.string));
-    var it = node.parts.iterator;
-    while (it.moveNext()) {
-      ast.StringInterpolationPart part = it.current;
-      arguments.add(visit(part.expression));
-      arguments.add(visitLiteralString(part.string));
-    }
-    return irBuilder.buildStringConcatenation(arguments);
+    List<ir.Primitive> parts = <ir.Primitive>[];
+    buildStringParts(node, parts);
+    return irBuilder.buildStringConcatenation(parts);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    return buildConstant(getConstantForNode(node));
+    return irBuilder.buildConstant(getConstantForNode(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
   ir.Primitive buildStaticNoSuchMethod(
@@ skipping 533 matching lines @@
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
   /// Returns [true], if the analysis could not determine that the type
   /// arguments for the class [cls] are never used in the program.
   bool requiresRuntimeTypesFor(ClassElement cls) {
     return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
   }
 
+  FunctionElement get stringifyFunction {
+    return _backend.getStringInterpolationHelper();
+  }
+
   FunctionElement get throwTypeErrorHelper => _backend.getThrowTypeError();
 
   ClassElement get nullClass => _compiler.nullClass;
 
   DartType unaliasType(DartType type) => type.unalias(_compiler);
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 }
@@ skipping 762 matching lines @@
         [irBuilder.buildStringConstant(element.name)]);
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     return buildStaticFieldGet(field, src);
   }
 
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
-    ConstantExpression constant =
-        backend.constants.getConstantForVariable(field);
+    ConstantValue constant = getConstantForVariable(field);
     if (constant != null && !field.isAssignable) {
-      return buildConstant(constant);
+      return irBuilder.buildConstant(constant);
     } else if (backend.constants.lazyStatics.contains(field)) {
       return irBuilder.buildStaticFieldLazyGet(field, src);
     } else {
       return irBuilder.buildStaticFieldGet(field, src);
     }
   }
 
   /// Build code to handle foreign code, that is, native JavaScript code, or
   /// builtin values and operations of the backend.
   ir.Primitive handleForeignCode(ast.Send node,
@@ skipping 123 matching lines @@
 
       case 'JS_INTERCEPTOR_CONSTANT':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
         ir.Primitive argumentValue = visit(argument);
         if (argumentValue is ir.Constant && argumentValue.value.isType) {
           TypeConstantValue constant = argumentValue.value;
           ConstantValue interceptorValue =
               new InterceptorConstantValue(constant.representedType);
-          return irBuilder.buildConstant(argumentValue.expression,
-              interceptorValue);
+          return irBuilder.buildConstant(interceptorValue);
         } else {
           internalError(argument, 'expected Type as argument');
         }
         break;
 
       case 'JS_EFFECT':
         return irBuilder.buildNullConstant();
 
       case 'JS_GET_NAME':
         validateArgumentCount(exactly: 1);
@@ skipping 126 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }