Make string juxtaposition combine properly with string interpolations.

frog/leg/compile_time_constants.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 Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   /** [isInt] implies [isNum]. */
   bool isInt() => false;
@@ skipping 41 matching lines @@
   abstract void writeJsCode(StringBuffer buffer, ConstantHandler handler);
 }
 
 class PrimitiveConstant extends Constant {
   abstract get value();
   const PrimitiveConstant();
 
   bool operator ==(var other) {
     if (other is !PrimitiveConstant) return false;
     PrimitiveConstant otherPrimitive = other;
-    // We use == instead of === so that DartStrings compare correctly. 
+    // We use == instead of === so that DartStrings compare correctly.
     return value == otherPrimitive.value;
   }
 
   String toString() => value.toString();
 }
 
 class NullConstant extends PrimitiveConstant {
   const NullConstant();
   bool isNull() => true;
   get value() => null;
@@ skipping 39 matching lines @@
       if (other.isInt()) {
         int right = rightNum;
         switch (op) {
           case "+": return new IntConstant(value + right);
           case "-": return new IntConstant(value - right);
           case "*": return new IntConstant(value * right);
           case "%": return new IntConstant(value % right);
           case "~/": return new IntConstant(value ~/ right);
           case "|": return new IntConstant(value | right);
           case "&": return new IntConstant(value & right);
-          case "^": return new IntConstant(value ^ right);        
+          case "^": return new IntConstant(value ^ right);
           case "<<":
             // TODO(floitsch): find a better way to guard against shifts to the
             // left.
             if (right > 100) return null;
             if (right < 0) return null;
             return new IntConstant(value << right);
           case ">>":
             if (right < 0) return null;
             return new IntConstant(value >> right);
         }
@@ skipping 31 matching lines @@
   bool isDouble() => true;
 
   void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     if (value.isNaN()) {
       buffer.add("(0/0)");
     } else if (value == double.INFINITY) {
       buffer.add("(1/0)");
     } else if (value == -double.INFINITY) {
       buffer.add("(-1/0)");
     } else {
-      buffer.add("($value)");        
+      buffer.add("($value)");
     }
   }
 
   DoubleConstant unaryFold(String op) {
     if (op == "-") return new DoubleConstant(-value);
     return null;
   }
 
   Constant binaryFold(String op, Constant other) {
     if (other.isNum()) {
@@ skipping 77 matching lines @@
     ConstantHandler.writeEscapedString(value, buffer, (reason) {
       throw new CompilerCancelledException(reason);
     });
     buffer.add("'");
   }
 
   Constant binaryFold(String op, Constant other) {
     if (other.isString() && op == "+") {
       StringConstant otherString = other;
       DartString right = otherString.value;
-      return new StringConstant(new ConsDartString(value, right));
+      return new StringConstant(new DartString.cons(value, right));
     }
     // Visit super in case the [op] was "==", "===", "!=" or "!===".
     return super.binaryFold(op, other);
   }
 
   bool operator ==(var other) {
     if (other is !StringConstant) return false;
     StringConstant otherString = other;
     return (_hashCode == otherString._hashCode) && (value == otherString.value);
   }
 
   int hashCode() => _hashCode;
 }
 
 class ObjectConstant extends Constant {
   final Type type;
 
   ObjectConstant(this.type);
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   int _hashCode;
 
   ListConstant(Type type, this.entries) : super(type) {
-    // TODO(floitsch): create a better hash. 
+    // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant input in entries) hash ^= input.hashCode();
     _hashCode = hash;
   }
   bool isList() => true;
 
   void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     // TODO(floitsch): we should not need to go through the compiler to make
     // the list constant.
     String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
@@ skipping 26 matching lines @@
 
   int hashCode() => _hashCode;
 }
 
 class ConstructedConstant extends ObjectConstant {
   final List<Constant> fields;
   int _hashCode;
 
   ConstructedConstant(Type type, this.fields) : super(type) {
     assert(type !== null);
-    // TODO(floitsch): create a better hash. 
+    // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode();
     }
     hash ^= type.element.hashCode();
     _hashCode = hash;
   }
   bool isConstructedObject() => true;
 
   void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
@@ skipping 160 matching lines @@
   List<Constant> getConstantsForEmission() {
     return compiledConstants.getKeys();
   }
 
   String getNameForConstant(Constant constant) {
     return compiledConstants[constant];
   }
 
   StringBuffer writeJsCode(StringBuffer buffer, Constant value) {
     value.writeJsCode(buffer, this);
-    return buffer;    
+    return buffer;
   }
 
   StringBuffer writeJsCodeForVariable(StringBuffer buffer,
                                       VariableElement element) {
     if (!initialVariableValues.containsKey(element)) {
       buffer.add("(void 0)");
       return buffer;
       // TODO(floitsch): reenable the following lines, once we fixed the rest
       // of the compiler.
       /*
       compiler.internalError("No initial value for given element",
                              element: element);
       */
     }
     Constant constant = initialVariableValues[element];
     if (constant.isObject()) {
       String name = compiledConstants[constant];
       buffer.add("${compiler.namer.ISOLATE}.prototype.$name");
     } else {
-      writeJsCode(buffer, constant);      
+      writeJsCode(buffer, constant);
     }
     return buffer;
   }
 
   /**
    * Write the contents of the quoted string to a [StringBuffer] in
    * a form that is valid as JavaScript string literal content.
    * The string is assumed quoted by single quote characters.
    */
   static void writeEscapedString(DartString string,
@@ skipping 65 matching lines @@
 
   visitNode(Node node) {
     compiler.unimplemented("CompileTimeConstantEvaluator", node: node);
   }
 
   Constant visitLiteralBool(LiteralBool node) {
     // TODO(floitsch): make BoolConstant a factory and cache the two values
     // there.
     return node.value ? const BoolConstant(true) : const BoolConstant(false);
   }
-  
+
   Constant visitLiteralDouble(LiteralDouble node) {
     return new DoubleConstant(node.value);
   }
-  
+
   Constant visitLiteralInt(LiteralInt node) {
     return new IntConstant(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst()) error(node);
     List arguments = [];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
@@ skipping 71 matching lines @@
                                                      arguments);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }