Make string juxtaposition combine properly with string interpolations.

frog/leg/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 1307 matching lines @@
     assert(op.token.kind !== PLUS_TOKEN);
     HInstruction operand = pop();
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       HConstant typedOperand = operand;
       Constant constant = typedOperand.constant;
       Constant folded = constant.unaryFold(op.source.stringValue);
       if (folded !== null) {
         stack.add(graph.addConstant(folded));
         return;
-      }      
+      }
     }
     HInstruction target =
         new HStatic(interceptors.getPrefixOperatorInterceptor(op));
     add(target);
     switch (op.source.stringValue) {
       case "-": push(new HNegate(target, operand)); break;
       case "~": push(new HBitNot(target, operand)); break;
       default: unreachable();
     }
   }
@@ skipping 294 matching lines @@
           SourceString name = selector.namedArguments[i];
           if (name == parameter.name) {
             foundIndex = i;
             break;
           }
         }
         if (foundIndex != -1) {
           list.add(namedArguments[foundIndex]);
         } else {
           Constant constant = compiler.compileVariable(parameter);
-          list.add(graph.addConstant(constant)); 
+          list.add(graph.addConstant(constant));
         }
       }
     }
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty(); link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
@@ skipping 620 matching lines @@
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     work.allowSpeculativeOptimization = false;
     visit(node.expression);
     HInstruction expression = pop();
+
     Link cases = node.cases.nodes;
     int count = 0;
     handleThen() {
       if (cases.head.statements.nodes.isEmpty()) {
         compiler.unimplemented('fall-through', node: cases.head);
       }
       visit(cases.head.statements);
       cases = cases.tail;
     }
     handleElse() {
@@ skipping 164 matching lines @@
     // Normally, we would call [close] here. However, then we hit
     // another unimplemented feature: aborting loop body. Simply
     // calling [add] does not work as it asserts that the instruction
     // isn't a control flow instruction. So we inline parts of [add].
     current.addAfter(current.last, new HThrow(message));
     if (isExpression) {
       stack.add(graph.addConstantNull());
     }
   }
 }