Simplify generated code for string interpolation by delaying the constant folding.

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 2572 matching lines @@
   void visitLiteralString(LiteralString node) {
     stack.add(graph.addConstantString(node.dartString, node));
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
       stack.add(graph.addConstantString(node.dartString, node));
       return;
     }
-    int offset = node.getBeginToken().charOffset;
-    StringBuilderVisitor stringBuilder =
-        new StringBuilderVisitor(this, offset);
+    StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result(node));
   }
 
   void visitLiteralNull(LiteralNull node) {
     stack.add(graph.addConstantNull());
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
@@ skipping 131 matching lines @@
     open(joinBlock);
 
     localsHandler.mergeWith(thenLocals, joinBlock);
     HPhi phi = new HPhi.manyInputs(null,
         <HInstruction>[thenInstruction, elseInstruction]);
     joinBlock.addPhi(phi);
     stack.add(phi);
   }
 
   visitStringInterpolation(StringInterpolation node) {
-    int offset = node.getBeginToken().charOffset;
-    StringBuilderVisitor stringBuilder =
-        new StringBuilderVisitor(this, offset);
+    StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result(node));
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
     compiler.internalError('visitStringInterpolation should not be called',
                            node: node);
   }
 
@@ skipping 523 matching lines @@
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
  * TODO(lrn): Consider whether to handle compile time constant int/boolean
  * expressions as well.
  */
 class StringBuilderVisitor extends AbstractVisitor {
   final SsaBuilder builder;
-  final Element stringConcat;
-  final Element stringToString;
 
   /**
-   * Offset used for the synthetic operator token used by concat.
-   * Can probably be removed when we stop using String.operator+.
-   */
-  final int offset;
-
-  /**
-   * Used to collect concatenated string literals into a single literal
-   * instead of introducing unnecessary concatenations.
-   */
-  DartString literalAccumulator = const LiteralDartString("");
-
-  /**
-   * The string value generated so far (not including that which is still
-   * in [literalAccumulator]).
+   * The string value generated so far.
    */
   HInstruction prefix = null;

[floitsch, 2012/06/06 12:13:34]

Maybe rename to 'result' and remove result-method?

[kasperl, 2012/06/06 13:31:03]

Done.

 
-  StringBuilderVisitor(builder, this.offset)
-    : this.builder = builder,
-      stringConcat = builder.compiler.findHelper(
-          const SourceString("stringConcat")),
-      stringToString = builder.compiler.findHelper(
-          const SourceString("stringToString"));
+  StringBuilderVisitor(this.builder);
 
   void visit(Node node) {
     node.accept(this);
   }
 
   visitNode(Node node) {
     builder.compiler.internalError('unexpected node', node: node);
   }
 
   void visitExpression(Node node) {
-    flushLiterals(node);
     node.accept(builder);
-    HInstruction asString = buildToString(node, builder.pop());
-    prefix = buildConcat(prefix, asString);
-  }
-
-  void visitLiteralNull(LiteralNull node) {
-    addLiteral(const LiteralDartString("null"));
-  }
-
-  void visitLiteralInt(LiteralInt node) {
-    addLiteral(new DartString.literal(node.value.toString()));
-  }
-
-  void visitLiteralDouble(LiteralDouble node) {
-    addLiteral(new DartString.literal(node.value.toString()));
-  }
-
-  void visitLiteralBool(LiteralBool node) {
-    addLiteral(node.value ? const LiteralDartString("true")
-                          : const LiteralDartString("false"));
+    HInstruction expression = builder.pop();
+    prefix = (prefix === null) ? expression : concat(prefix, expression);
   }
 
   void visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
   }
 
   void visitStringInterpolationPart(StringInterpolationPart node) {
     visit(node.expression);
     visit(node.string);
   }
 
-  void visitLiteralString(LiteralString node) {
-    addLiteral(node.dartString);
-  }
-
   void visitStringJuxtaposition(StringJuxtaposition node) {
     node.visitChildren(this);
   }
 
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
-  /**
-   * Add another literal string to the literalAccumulator.
-   */
-  void addLiteral(DartString dartString) {
-    literalAccumulator = new DartString.concat(literalAccumulator, dartString);
-  }
-
-  /**
-   * Combine the strings in [literalAccumulator] into the prefix instruction.
-   * After this, the [literalAccumulator] is empty and [prefix] is non-null.
-   */
-  void flushLiterals(Node node) {
-    if (literalAccumulator.isEmpty()) {
-      if (prefix === null) {
-        prefix = builder.graph.addConstantString(literalAccumulator, node);
-      }
-      return;
-    }
-    HInstruction string =
-        builder.graph.addConstantString(literalAccumulator, node);
-    literalAccumulator = new DartString.empty();
-    if (prefix !== null) {
-      prefix = buildConcat(prefix, string);
-    } else {
-      prefix = string;
-    }
-  }
-
-  HInstruction buildConcat(HInstruction left, HInstruction right) {
-    HStatic target = new HStatic(stringConcat);
-    builder.add(target);
-    builder.push(new HAdd(target, left, right));
-    return builder.pop();
-  }
-
-  HInstruction buildToString(Node node, HInstruction input) {
-    HStatic target = new HStatic(stringToString);
-    builder.add(target);
-    builder.push(new HInvokeStatic(Selector.INVOCATION_1,
-                                   <HInstruction>[target, input],
-                                   HType.STRING));
-    return builder.pop();
+  HInstruction concat(HInstruction left, HInstruction right) {
+    HInstruction result = new HStringConcat([left, right]);
+    builder.add(result);
+    return result;
   }
 
   HInstruction result(Node node) {

[floitsch, 2012/06/06 12:13:34]

If you keep the result-method, remove the argument?

-    flushLiterals(node);
     return prefix;
   }
 }