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);
   R visitContinueStatement(ContinueStatement node);
   R visitDoWhile(DoWhile node);
   R visitEmptyStatement(EmptyStatement node);
   R visitExpressionStatement(ExpressionStatement node);
   R visitFor(For node);
   R visitForInStatement(ForInStatement node);
   R visitFunctionDeclaration(FunctionDeclaration node);
   R visitFunctionExpression(FunctionExpression node);
   R visitIdentifier(Identifier node);
   R visitIf(If node);
   R visitLabeledStatement(LabeledStatement node);
   R visitLiteralBool(LiteralBool node);
   R visitLiteralDouble(LiteralDouble node);
   R visitLiteralInt(LiteralInt node);
   R visitLiteralList(LiteralList node);
   R visitLiteralMap(LiteralMap node);
   R visitLiteralMapEntry(LiteralMapEntry node);
   R visitLiteralNull(LiteralNull node);
   R visitLiteralString(LiteralString node);
-  R visitLiteralStringJuxtaposition(LiteralStringJuxtaposition node);
+  R visitStringJuxtaposition(StringJuxtaposition node);
   R visitModifiers(Modifiers node);
   R visitNamedArgument(NamedArgument node);
   R visitNewExpression(NewExpression node);
   R visitNodeList(NodeList node);
   R visitOperator(Operator node);
   R visitParenthesizedExpression(ParenthesizedExpression node);
   R visitReturn(Return node);
   R visitScriptTag(ScriptTag node);
   R visitSend(Send node);
   R visitSendSet(SendSet node);
@@ skipping 88 matching lines @@
   NodeList asNodeList() => null;
   Operator asOperator() => null;
   ParenthesizedExpression asParenthesizedExpression() => null;
   Return asReturn() => null;
   ScriptTag asScriptTag() => null;
   Send asSend() => null;
   SendSet asSendSet() => null;
   Statement asStatement() => null;
   StringInterpolation asStringInterpolation() => null;
   StringInterpolationPart asStringInterpolationPart() => null;
+  StringJuxtaposition asStringJuxtaposition() => null;
   SwitchCase asSwitchCase() => null;
   SwitchStatement asSwitchStatement() => null;
   Throw asThrow() => null;
   TryStatement asTryStatement() => null;
   TypeAnnotation asTypeAnnotation() => null;
   Typedef asTypedef() => null;
   VariableDefinitions asVariableDefinitions() => null;
   While asWhile() => null;
 
   bool isValidBreakTarget() => false;
@@ skipping 572 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> {
-  // This is a convenience constructor. If you need a const literal DartString,
-  // use [const LiteralDartString(string)] directly.
-  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);
-  const DartString();
-  abstract int get length();
-  bool isEmpty() => length == 0;
-  abstract Iterator<int> iterator();
-  abstract String slowToString();
-
-  bool operator ==(var other) {
-    if (other is !DartString) return false;
-    DartString otherString = other;
-    if (length != otherString.length) return false;
-    Iterator it1 = iterator();
-    Iterator it2 = otherString.iterator();
-    while (it1.hasNext()) {
-      if (it1.next() != it2.next()) return false;
-    }
-    return true;
-  }
-  String toString() => "DartString#${length}:${slowToString()}";
-  abstract SourceString get source();
-}
-
-class LiteralDartString extends DartString {
-  final String string;
-  const LiteralDartString(this.string);
-  int get length() => string.length;
-  Iterator<int> iterator() => new StringCodeIterator(string);
-  String slowToString() => string;
-  SourceString get source() => new StringWrapper(string);
-}
-
-class SourceBasedDartString extends DartString {
-  String toStringCache = null;
-  final SourceString source;
-  final int length;
-  SourceBasedDartString(this.source, this.length);
-  abstract Iterator<int> iterator();
-}
-
-class RawSourceDartString extends SourceBasedDartString {
-  RawSourceDartString(source, length) : super(source, length);
-  Iterator<int> iterator() => source.iterator();
-  String slowToString() {
-    if (toStringCache !== null) return toStringCache;
-    toStringCache  = source.slowToString();
-    return toStringCache;
-  }
-}
-
-class EscapedSourceDartString extends SourceBasedDartString {
-  EscapedSourceDartString(source, length) : super(source, length);
-  Iterator<int> iterator() {
-    if (toStringCache !== null) return new StringCodeIterator(toStringCache);
-    return new StringEscapeIterator(source);
-  }
-  String slowToString() {
-    if (toStringCache !== null) return toStringCache;
-    StringBuffer buffer = new StringBuffer();
-    StringEscapeIterator it = new StringEscapeIterator(source);
-    while (it.hasNext()) {
-      buffer.addCharCode(it.next());
-    }
-    toStringCache = buffer.toString();
-    return toStringCache;
-  }
-}
-
-class ConsDartString extends DartString {
-  final DartString left;
-  final DartString right;
-  final int length;
-  int hashCache = null;
-  String toStringCache;
-  ConsDartString(DartString left, DartString right)
-      : this.left = left,
-        this.right = right,
-        length = left.length + right.length;
-
-  Iterator<int> iterator() => new ConsDartStringIterator(this);
-
-  String slowToString() {
-    if (toStringCache !== null) return toStringCache;
-    toStringCache = left.slowToString().concat(right.slowToString());
-    return toStringCache;
-  }
-  SourceString get source() => new StringWrapper(slowToString());
-}
-
-class ConsDartStringIterator implements Iterator<int> {
-  Iterator<int> current;
-  DartString right;
-  bool hasNextLookAhead;
-  ConsDartStringIterator(ConsDartString cons)
-      : current = cons.left.iterator(),
-        right = cons.right {
-    hasNextLookAhead = current.hasNext();
-    if (!hasNextLookAhead) {
-      nextPart();
-    }
-  }
-  bool hasNext() {
-    return hasNextLookAhead;
-  }
-  int next() {
-    assert(hasNextLookAhead);
-    int result = current.next();
-    hasNextLookAhead = current.hasNext();
-    if (!hasNextLookAhead) {
-      nextPart();
-    }
-    return result;
-  }
-  void nextPart() {
-    if (right !== null) {
-      current = right.iterator();
-      right = null;
-      hasNextLookAhead = current.hasNext();
-    }
-  }
-}
-
 /**
- *Iterator that returns the actual string contents of a string with escapes.
- */
-class StringEscapeIterator implements Iterator<int>{
-  final Iterator<int> source;
-  StringEscapeIterator(SourceString source) : this.source = source.iterator();
-  bool hasNext() => source.hasNext();
-  int next() {
-    int code = source.next();
-    if (code !== $BACKSLASH) {
-      return code;
-    }
-    code = source.next();
-    if (code === $n) return $LF;
-    if (code === $r) return $CR;
-    if (code === $t) return $TAB;
-    if (code === $b) return $BS;
-    if (code === $f) return $FF;
-    if (code === $v) return $VTAB;
-    if (code === $x) {
-      int value = hexDigitValue(source.next());
-      value = value * 16 + hexDigitValue(source.next());
-      return value;
-    }
-    if (code === $u) {
-      int value = 0;
-      code = source.next();
-      if (code === $OPEN_CURLY_BRACKET) {
-        for (code = source.next();
-             code != $CLOSE_CURLY_BRACKET;
-             code = source.next()) {
-           value = value * 16 + hexDigitValue(code);
-        }
-        return value;
-      }
-      // Four digit hex value.
-      value = hexDigitValue(code);
-      for (int i = 0; i < 3; i++) {
-        code = source.next();
-        value = value * 16 + hexDigitValue(code);
-      }
-      return value;
-    }
-    return code;
-  }
+  * Marker interface uniting the classes that can be the result of
+  * a string literal.
+  */
+interface StringNode /* extends Node  - when supported */ {

[ahe, 2012/03/19 08:13:08]

LiteralString currently extends Literal. That's not necessary. Alternatively,
StringNode should extend Literal.

Then I think StringNode can be made a proper class.

[Lasse Reichstein Nielsen, 2012/03/19 09:57:48]

I'll try.
I'm not sure StringNode makes a good subclass of Literal, since a
StringInterpolation won't have a meaningful "value".

+  final DartString dartString;
+  final bool isInterpolation;
+  // Use until StringNode can extend Node.
+  Node asNode();
 }
 
-
-class LiteralString extends Literal<SourceString> {
-  /** Set on validated string literals. */
-  final DartString dartString = null;
+class LiteralString extends Literal<SourceString> implements StringNode {
+  /** Non-null on validated string literals. */
+  final DartString dartString;
 
   LiteralString(Token token, this.dartString) : super(token, null);
 
   LiteralString asLiteralString() => this;
 
+  Node asNode() => this;
+  bool get isInterpolation() => false;
   bool isValidated() => dartString !== null;
 
   SourceString get value() => token.value;
 
   accept(Visitor visitor) => visitor.visitLiteralString(this);
 }
 
 class LiteralNull extends Literal<SourceString> {
   LiteralNull(Token token) : super(token, null);
 
@@ skipping 290 matching lines @@
   visitChildren(Visitor visitor) => nodes.accept(visitor);
 
   bool isStatic() => (flags & FLAG_STATIC) != 0;
   bool isAbstract() => (flags & FLAG_ABSTRACT) != 0;
   bool isFinal() => (flags & FLAG_FINAL) != 0;
   bool isVar() => (flags & FLAG_VAR) != 0;
   bool isConst() => (flags & FLAG_CONST) != 0;
   bool isFactory() => (flags & FLAG_FACTORY) != 0;
 }
 
-class StringInterpolation extends Expression {
+class StringInterpolation extends Expression implements StringNode {
   final LiteralString string;
   final NodeList parts;
 
   StringInterpolation(this.string, this.parts);
 
   StringInterpolation asStringInterpolation() => this;
 
+  DartString get dartString() => null;
+  Node asNode() => this;
+  bool get isInterpolation() => true;
+
   accept(Visitor visitor) => visitor.visitStringInterpolation(this);
 
   visitChildren(Visitor visitor) {
     string.accept(visitor);
     parts.accept(visitor);
   }
 
   Token getBeginToken() => string.getBeginToken();
 
   Token getEndToken() => parts.getEndToken();
@@ skipping 12 matching lines @@
   visitChildren(Visitor visitor) {
     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;
+/**
+ * A class representing juxtaposed string literals.
+ * The string literals can be both plain literals and string interpolations.
+ */
+class StringJuxtaposition extends Expression implements StringNode {
+  final Expression first;
+  final Expression second;
+  // Caches the check for whether this juxtaposition contains a string
+  // interpolation
+  bool _isInterpolation = null;
+  // Caches a Dart string representation of the entire juxtaposition's
+  // content. Only juxtapositions that don't (transitively) contains
+  // interpolations have a static representation.
+  DartString _dartString = null;
 
-  LiteralStringJuxtaposition(Link<Expression> literals)
-      : this.literals = literals,
-        super(literals.head.getBeginToken(), concatenateLiterals(literals));
+  StringJuxtaposition(this.first, this.second);
 
-  static DartString concatenateLiterals(Link<Expression> literals) {
-    assert(!literals.isEmpty());
-    LiteralString literal = literals.head;
-    if (literals.tail.isEmpty()) {
-      return literal.dartString;
+  StringJuxtaposition asStringJuxtaposition() => this;
+
+  bool get isInterpolation() {
+    if (_isInterpolation === null) {
+      _isInterpolation = (first.accept(const IsInterpolationVisitor()) ||
+                          second.accept(const IsInterpolationVisitor()));
     }
-    return new ConsDartString(literal.dartString,
-                              concatenateLiterals(literals.tail));
+    return _isInterpolation;
   }
 
-  SourceString get value() => null;
-
-  accept(Visitor visitor) => visitor.visitLiteralStringJuxtaposition(this);
-
-  visitChildren(Visitor visitor) {
-    for (Expression literal in literals) {
-      literal.accept(visitor);
+  /**
+   * Retrieve a single DartString that represents this entire juxtaposition
+   * of string literals.
+   * Should only be called if [isInterpolation] returns false.
+   */
+  DartString get dartString() {
+    if (_dartString === null) {
+      DartString firstString = first.accept(const GetDartStringVisitor());
+      DartString secondString = second.accept(const GetDartStringVisitor());
+      if (firstString === null || secondString === null) {
+        return null;
+      }
+      _dartString = new DartString.concat(firstString, secondString);
     }
+    return _dartString;
   }
 
-  Token getBeginToken() => literals.head.getBeginToken();
+  Node asNode() => this;
 
-  Token getEndToken() {
-    Link<Expression> current = literals;
-    Expression lastExpression = null;
-    while (!current.isEmpty()) {
-      lastExpression = current.head;
-      current = current.tail;
-    }
-    return lastExpression.getEndToken();
+  accept(Visitor visitor) => visitor.visitStringJuxtaposition(this);
+
+  void visitChildren(Visitor visitor) {
+    first.accept(visitor);
+    second.accept(visitor);
   }
+
+  Token getBeginToken() => first.getBeginToken();
+
+  Token getEndToken() => second.getEndToken();
 }
 
 class EmptyStatement extends Statement {
   final Token semicolonToken;
 
   EmptyStatement(this.semicolonToken);
 
   EmptyStatement asEmptyStatement() => this;
 
   accept(Visitor visitor) => visitor.visitEmptyStatement(this);
@@ skipping 249 matching lines @@
 
   Node getBody() {
     if (statement is! LabeledStatement) return statement;
     LabeledStatement labeled = statement;
     return labeled.getBody();
   }
 }
 
 class ScriptTag extends Node {
   final Identifier tag;
-  final LiteralString argument;
+  final StringNode argument;
   final Identifier prefixIdentifier;
-  final LiteralString prefix;
+  final StringNode prefix;
 
   final Token beginToken;
   final Token endToken;
 
   ScriptTag(this.tag, this.argument, this.prefixIdentifier, this.prefix,
             this.beginToken, this.endToken);
 
   bool isImport() => tag.source == const SourceString("import");
   bool isSource() => tag.source == const SourceString("source");
   bool isLibrary() => tag.source == const SourceString("library");
@@ skipping 122 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);
   }
 }
+
+class GetDartStringVisitor extends AbstractVisitor<DartString> {
+  const GetDartStringVisitor();
+  DartString visitNode(Node node) => null;
+  DartString visitStringJuxtaposition(StringJuxtaposition node)
+      => node.dartString;
+  DartString visitLiteralString(LiteralString node) => node.dartString;
+}
+
+class IsInterpolationVisitor extends AbstractVisitor<bool> {
+  const IsInterpolationVisitor();
+  bool visitNode(Node node) => false;
+  bool visitStringInterpolation(StringInterpolation node) => true;
+  bool visitStringJuxtaposition(StringJuxtaposition node)
+      => node.isInterpolation;
+}