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 702 matching lines @@
   int get leftQuoteLength() => (raw ? 1 : 0) + leftQuoteCharCount;
   int get rightQuoteLength() => (leftQuoteCharCount > 2) ? 3 : 1;
   static StringQuoting getQuoting(int quote, bool raw, int quoteLength) {
     int index = quoteLength - 1;
     if (quoteLength > 2) index -= 1;
     return mapping[(raw ? 1 : 0) + index * 2 + (quote === $SQ ? 8 : 0)];
   }
 }
 
 
 class DartString implements Iterable<int> {

[ahe, 2012/03/12 09:31:04]

What are these classes doing in this file? They are not AST nodes.

Why do we have so many classes for handling strings?

   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.concat(DartString first, DartString second) {
+    if (first.isEmpty()) return second;
+    if (second.isEmpty()) return first;
+    return new ConsDartString(first, second);
+  }
   DartString();
   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;
@@ skipping 508 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.concat(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);
   }
 }