Add support for implicitly concatenating adjacent string literals.

frog/parser.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.
 
 // TODO(jimhug): Error recovery needs major work!
 /**
  * A simple recursive descent parser for the dart language.
  *
  * This parser is designed to be more permissive than the official
  * Dart grammar.  It is expected that many grammar errors would be
@@ skipping 1097 matching lines @@
       case TokenKind.INTEGER:
         var t = _next();
         return _makeLiteral(Value.fromInt(Math.parseInt(t.text), t.span));
 
       case TokenKind.DOUBLE:
         var t = _next();
         return _makeLiteral(
           Value.fromDouble(Math.parseDouble(t.text), t.span));
 
       case TokenKind.STRING:
-      var t = _next();
-      return _makeLiteral(Value.fromString(t.value, t.span));
-
       case TokenKind.STRING_PART:
-        return stringInterpolation();
+        return adjacentStrings();
 
       case TokenKind.LT:
         return finishTypedLiteral(start, false);
 
       case TokenKind.VOID:
       case TokenKind.VAR:
       case TokenKind.FINAL:
         return declaredIdentifier(false);
 
       default:
         if (!_peekIdentifier()) {
           // TODO(jimhug): Better error message.
           _errorExpected('expression');
         }
         return new VarExpression(identifier(), _makeSpan(start));
     }
   }
 
+  adjacentStrings() {
+    int start = _peekToken.start;
+    List<Expression> strings = [];
+    while (_peek() == TokenKind.STRING || _peek() == TokenKind.STRING_PART) {
+      Expression part = null;
+      if (_peek() == TokenKind.STRING) {
+        var t = _next();
+        part = _makeLiteral(Value.fromString(t.value, t.span));
+      } else {
+        part = stringInterpolation();
+      }
+      strings.add(part);
+    }
+    if (strings.length == 1) {
+      return strings[0];
+    } else {
+      assert(!strings.isEmpty());
+      return new StringConcatExpression(strings, _makeSpan(start));
+    }
+  }
+
   stringInterpolation() {
     int start = _peekToken.start;
     var pieces = new List<Expression>();
     var startQuote = null, endQuote = null;
     while(_peekKind(TokenKind.STRING_PART)) {
       var token = _next();
       pieces.add(_makeLiteral(Value.fromString(token.value, token.span)));
       if (_maybeEat(TokenKind.LBRACE)) {
         pieces.add(expression());
         _eat(TokenKind.RBRACE);
@@ skipping 570 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }