Make string juxtaposition combine properly with string interpolations.

frog/leg/tree/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 Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCatchBlock(CatchBlock node);
   R visitClassNode(ClassNode node);
   R visitConditional(Conditional node);
@@ skipping 708 matching lines @@
   }
 }
 
 
 class DartString implements Iterable<int> {
   factory DartString.literal(String string) => new LiteralDartString(string);
   factory DartString.rawString(SourceString source, int length) =>
       new RawSourceDartString(source, length);
   factory DartString.escapedString(SourceString source, int length) =>
       new EscapedSourceDartString(source, length);
+  factory DartString.cons(DartString first, DartString second) {

[ngeoffray, 2012/03/08 10:37:09]

cons is very close to 'const' and I often get confused. Could it be something
like concat?

[Lasse Reichstein Nielsen, 2012/03/08 11:17:49]

ok, will do.

+    if (first.isEmpty()) return second;
+    if (second.isEmpty()) return first;
+    return new ConsDartString(first, second);
+  }
   DartString();

[ngeoffray, 2012/03/08 10:37:09]

Why do you still have this constructor? There should be a synthethized one
created for you.

[Lasse Reichstein Nielsen, 2012/03/08 11:17:49]

Isn't that only if I don't have any other constructors, and factories count?

[ngeoffray, 2012/03/08 11:21:21]

Yes, you're right. I got confused by the mix of factory constructors/empty
constructor.

   abstract int get length();
   bool isEmpty() => length == 0;
   abstract Iterator<int> iterator();
   abstract String toString();
 
   bool operator ==(var other) {
     if (other is !DartString) return false;
     DartString otherString = other;
     if (length != otherString.length) return false;
     Iterator it1 = iterator();
@@ skipping 507 matching lines @@
     expression.accept(visitor);
     string.accept(visitor);
   }
 
   Token getBeginToken() => expression.getBeginToken();
 
   Token getEndToken() => string.getEndToken();
 }
 
 class LiteralStringJuxtaposition extends LiteralString {
-  // List of either StringLiteral or StringInterpolation.
-  final Link<Expression> literals;
+  // List of StringLiterals.
+  final Link<LiteralString> literals;
 
-  LiteralStringJuxtaposition(Link<Expression> literals)
+  LiteralStringJuxtaposition(Link<LiteralString> literals)
       : this.literals = literals,
         super(literals.head.getBeginToken(), concatenateLiterals(literals));
 
-  static DartString concatenateLiterals(Link<Expression> literals) {
+  static DartString concatenateLiterals(Link<LiteralString> literals) {
     assert(!literals.isEmpty());
     LiteralString literal = literals.head;
-    if (literals.tail.isEmpty()) {
-      return literal.dartString;
+    // If any of the literals couldn't be validated, then nor can their
+    // concatenation.
+    if (!literal.isValidated()) return null;
+    DartString accumulator = literal.dartString;
+    literals = literals.tail;
+    while (!literals.isEmpty()) {
+      literal = literals.head;
+      if (!literal.isValidated()) return null;
+      accumulator = new DartString.cons(accumulator, literal.dartString);
+      literals = literals.tail;
     }
-    return new ConsDartString(literal.dartString,
-                              concatenateLiterals(literals.tail));
+    return accumulator;
   }
 
   SourceString get value() => null;
 
   accept(Visitor visitor) => visitor.visitLiteralStringJuxtaposition(this);
 
   visitChildren(Visitor visitor) {
     for (Expression literal in literals) {
       literal.accept(visitor);
     }
@@ skipping 414 matching lines @@
   static bool isConstructorRedirect(Send node) {
     return (node.receiver === null &&
             node.selector.asIdentifier() !== null &&
             node.selector.asIdentifier().isThis()) ||
            (node.receiver !== null &&
             node.receiver.asIdentifier() !== null &&
             node.receiver.asIdentifier().isThis() &&
             node.selector.asIdentifier() !== null);
   }
 }