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

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 33 matching lines @@
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
+  R visitStringConcat(HStringConcat node);
   R visitSubtract(HSubtract node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
   R visitTruncatingDivide(HTruncatingDivide node);
   R visitTry(HTry node);
   R visitTypeGuard(HTypeGuard node);
   R visitTypeConversion(HTypeConversion node);
 }
 
 class HGraphVisitor {
@@ skipping 230 matching lines @@
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitInstruction(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
+  visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
   visitTry(HTry node) => visitControlFlow(node);
   visitTruncatingDivide(HTruncatingDivide node) => visitBinaryArithmetic(node);
   visitTypeGuard(HTypeGuard node) => visitCheck(node);
   visitIs(HIs node) => visitInstruction(node);
   visitTypeConversion(HTypeConversion node) => visitCheck(node);
 }
 
 class SubGraph {
@@ skipping 1884 matching lines @@
       sourceElement = input.sourceElement;
   }
 
   HType get guaranteedType() => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool hasSideEffects() => checked;
 }
 
+class HStringConcat extends HInstruction {
+  HStringConcat(inputs) : super(inputs);
+  HType get guaranteedType() => HType.STRING;
+
+  accept(HVisitor visitor) => visitor.visitStringConcat(this);
+  toString() => "string concat";

[Lasse Reichstein Nielsen, 2012/06/06 12:11:40]

Should this class be allowed to have more than two inputs? Nothing seems to
prevent it, the optimize code handles it, but codegen doesn't.

If you don't expect to allow 3+ inputs later, consider adding left/right getters
to extract the inputs. Or just extend HInvokeBinary, if possible. Otherwise make
a comment about it.

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

Changed the constructor to take exactly two arguments (left and right).

+}
+
 /** Non-block-based (aka. traditional) loop information. */
 class HLoopInformation {
   final HBasicBlock header;
   final List<HBasicBlock> blocks;
   final List<HBasicBlock> backEdges;
   final List<LabelElement> labels;
   final TargetElement target;
 
   /** Corresponding block information for the loop. */
   HLoopBlockInformation loopBlockInformation;
@@ skipping 273 matching lines @@
                        this.catchBlock,
                        this.finallyBlock);
 
   HBasicBlock get start() => body.start;
   HBasicBlock get end() =>
       finallyBlock === null ? catchBlock.end : finallyBlock.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitTryInfo(this);
 }