Allow binary operators on compile-time-constants.

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 693 matching lines @@
       new RawSourceDartString(source, length);
   factory DartString.escapedString(SourceString source, int length) =>
       new EscapedSourceDartString(source, length);
   DartString();
   abstract int get length();
   bool isEmpty() => length == 0;
   // TODO(lrn): Is this test too expensive?
   bool definitelyEquals(DartString other) => toString() == other.toString();
   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();
+    Iterator it2 = otherString.iterator();
+    while (it1.hasNext()) {
+      if (it1.next() != it2.next()) return false;
+    }
+    return true;
+  }
 }
 
 class LiteralDartString extends DartString {
   final String string;
   LiteralDartString(this.string);
   int get length() => string.length;
   Iterator<int> iterator() => new StringCodeIterator(string);
   String toString() => string;
 }
 
@@ skipping 16 matching lines @@
 
 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 toString() {
     if (toStringCache !== null) return toStringCache;
     StringBuffer buffer = new StringBuffer();
-    StringEscapeIterator iterator = new StringEscapeIterator(source);
-    while (iterator.hasNext()) {
-      buffer.add(new String.fromCharCodes(<int>[iterator.next()]));
+    StringEscapeIterator it = new StringEscapeIterator(source);
+    while (it.hasNext()) {
+      buffer.add(new String.fromCharCodes(<int>[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 toString() {
+    if (toStringCache !== null) return toStringCache;
+    toStringCache = left.toString().concat(right.toString());
+    return toStringCache;
+  }
+}
+
+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();
@@ skipping 714 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);
   }
 }