Allow string literal concatenation in import clauses

runtime/vm/parser.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 4774 matching lines @@
 
 void Parser::ParseLibraryImportExport() {
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const intptr_t import_pos = TokenPos();
   ConsumeToken();
   if (CurrentToken() != Token::kSTRING) {
     ErrorMsg("library url expected");
   }
-  const String& url = *CurrentLiteral();
+  AstNode* url_literal = ParseStringLiteral(false);
+  ASSERT(url_literal->IsLiteralNode());
+  ASSERT(url_literal->AsLiteralNode()->literal().IsString());
+  const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   if (url.Length() == 0) {
     ErrorMsg("library url expected");
   }
-  ConsumeToken();
   String& prefix = String::Handle();
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
   Array& show_names = Array::Handle();
   Array& hide_names = Array::Handle();
   if (IsLiteral("show") || IsLiteral("hide")) {
     GrowableObjectArray& show_list =
@@ skipping 64 matching lines @@
   }
 }
 
 
 void Parser::ParseLibraryPart() {
   const intptr_t source_pos = TokenPos();
   ConsumeToken();  // Consume "part".
   if (CurrentToken() != Token::kSTRING) {
     ErrorMsg("url expected");
   }
-  const String& url = *CurrentLiteral();
-  ConsumeToken();
+  AstNode* url_literal = ParseStringLiteral(false);
+  ASSERT(url_literal->IsLiteralNode());
+  ASSERT(url_literal->AsLiteralNode()->literal().IsString());
+  const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   ExpectSemicolon();
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, source_pos, url));
   CallLibraryTagHandler(Dart_kSourceTag, source_pos, canon_url);
 }
 
 
 void Parser::ParseLibraryDefinition() {
   TRACE_PARSER("ParseLibraryDefinition");
 
@@ skipping 5063 matching lines @@
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token.
-AstNode* Parser::ParseStringLiteral() {
+AstNode* Parser::ParseStringLiteral(bool allow_interpolation) {
   TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
   const intptr_t literal_start = TokenPos();
   ASSERT(CurrentToken() == Token::kSTRING);
   Token::Kind l1_token = LookaheadToken(1);
   if ((l1_token != Token::kSTRING) &&
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   bool is_compiletime_const = true;
+  bool has_interpolation = false;
   GrowableArray<AstNode*> values_list;
   while (CurrentToken() == Token::kSTRING) {
     if (CurrentLiteral()->Length() > 0) {
       // Only add non-empty string sections to the values list
       // that will be concatenated.
       values_list.Add(new LiteralNode(TokenPos(), *CurrentLiteral()));
     }
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
+      if (!allow_interpolation) {
+        ErrorMsg("string interpolation not allowed in this context");
+      }
+      has_interpolation = true;
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
         expr = ParseExpr(kAllowConst, kConsumeCascades);
         ExpectToken(Token::kINTERPOL_END);
@@ skipping 12 matching lines @@
           // Change expr into a literal.
           expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr));
         } else {
           is_compiletime_const = false;
         }
       }
       values_list.Add(expr);
     }
   }
   if (is_compiletime_const) {
-    primary = new LiteralNode(literal_start, Interpolate(values_list));
+    if (has_interpolation) {
+      primary = new LiteralNode(literal_start, Interpolate(values_list));
+    } else {
+      const Array& strings = Array::Handle(Array::New(values_list.length()));
+      for (int i = 0; i < values_list.length(); i++) {
+        const Instance& part = values_list[i]->AsLiteralNode()->literal();
+        ASSERT(part.IsString());
+        strings.SetAt(i, String::Cast(part));
+      }
+      String& lit = String::ZoneHandle(String::ConcatAll(strings, Heap::kOld));
+      lit = Symbols::New(lit);
+      primary = new LiteralNode(literal_start, lit);
+    }
   } else {
     ArrayNode* values = new ArrayNode(
         TokenPos(),
         Type::ZoneHandle(Type::ArrayType()),
         values_list);
     primary = new StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
 
@@ skipping 94 matching lines @@
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (CurrentToken() == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
     primary = new LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
-    primary = ParseStringLiteral();
+    primary = ParseStringLiteral(true);
   } else if (CurrentToken() == Token::kNEW) {
     ConsumeToken();
     primary = ParseNewOperator(Token::kNEW);
   } else if (CurrentToken() == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
         (LookaheadToken(1) == Token::kLBRACE)) {
       primary = ParseCompoundLiteral();
     } else {
@@ skipping 401 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart