Get rid of support for string interpolation in #import strings.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 3942 matching lines @@
 
 void Parser::ParseLibraryImport() {
   TRACE_PARSER("ParseLibraryImport");
   while (CurrentToken() == Token::kIMPORT) {
     const intptr_t import_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
-    const String& url = *ParseImportStringLiteral();
+    const String& url = *CurrentLiteral();
+    ConsumeToken();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       if (!IsLiteral("prefix")) {
         ErrorMsg("prefix: expected");
       }
       ConsumeToken();
       ExpectToken(Token::kCOLON);
       if (CurrentToken() != Token::kSTRING) {
         ErrorMsg("prefix expected");
@@ skipping 43 matching lines @@
 
 void Parser::ParseLibraryInclude() {
   TRACE_PARSER("ParseLibraryInclude");
   while (CurrentToken() == Token::kSOURCE) {
     const intptr_t source_pos = TokenPos();
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
-    const String& url = *ParseImportStringLiteral();
+    const String& url = *CurrentLiteral();
+    ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
                                                url);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     CallLibraryTagHandler(kSourceTag, source_pos, canon_url);
   }
 }
 
@@ skipping 3998 matching lines @@
     } else {
       ASSERT(primary->primary().IsClass());
       ErrorMsg(ident_pos, "illegal reference to class or interface '%s'",
                ident.ToCString());
     }
   }
   return resolved;
 }
 
 
-// Resolve variables used in an import string literal.
-// If the variable name cannot be resolved issue an error message.
-// Currently we only resolve against the global map which is passed in
-// when the script is loaded.
-RawString* Parser::ResolveImportVar(intptr_t ident_pos, const String& ident) {
-  TRACE_PARSER("ResolveImportVar");
-  const Array& import_map =
-      Array::Handle(Isolate::Current()->object_store()->import_map());
-  if (!import_map.IsNull()) {
-    intptr_t length = import_map.Length();
-    intptr_t index = 0;
-    String& name = String::Handle();
-    while (index < (length - 1)) {
-      name ^= import_map.At(index);
-      if (name.Equals(ident)) {
-        name ^= import_map.At(index + 1);
-        return name.raw();
-      }
-      index += 2;
-    }
-  }
-  ErrorMsg(ident_pos, "import variable '%s' has not been defined",
-           ident.ToCString());
-  return String::null();
-}
-
-
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseType");
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   if (finalization == ClassFinalizer::kIgnore) {
@@ skipping 796 matching lines @@
         new ArgumentListNode(values->token_pos());
     interpolate_arg->Add(values);
     const String& cls_name = String::Handle(Symbols::StringBase());
     const String& func_name = String::Handle(Symbols::Interpolate());
     primary = MakeStaticCall(cls_name, func_name, interpolate_arg);
   }
   return primary;
 }
 
 
-// An import string literal consists of the concatenation of the next n tokens
-// that satisfy the EBNF grammar:
-// literal = kSTRING {{ interpol }+ kSTRING }
-// interpol = kINTERPOL_VAR
-// In other words, the scanner breaks down interpolated strings so that
-// a string literal always begins and ends with a kSTRING token, and
-// there are never two kSTRING tokens next to each other.
-String* Parser::ParseImportStringLiteral() {
-  TRACE_PARSER("ParseImportStringLiteral");
-  if ((CurrentToken() == Token::kSTRING) &&
-      (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
-      (LookaheadToken(1) != Token::kINTERPOL_START)) {
-    // Common case: no interpolation.
-    String* result = CurrentLiteral();
-    ConsumeToken();
-    return result;
-  }
-  // String interpolation needed.
-  String& result = String::ZoneHandle(Symbols::Empty());
-  String& resolved_name = String::Handle();
-  while (CurrentToken() == Token::kSTRING) {
-    result = String::Concat(result, *CurrentLiteral());
-    ConsumeToken();
-    if ((CurrentToken() != Token::kINTERPOL_VAR) &&
-        (CurrentToken() != Token::kINTERPOL_START)) {
-      break;
-    }
-    while ((CurrentToken() == Token::kINTERPOL_VAR) ||
-           (CurrentToken() == Token::kINTERPOL_START)) {
-      if (CurrentToken() == Token::kINTERPOL_START) {
-        ConsumeToken();
-        if (IsIdentifier()) {
-          resolved_name = ResolveImportVar(TokenPos(), *CurrentLiteral());
-          result = String::Concat(result, resolved_name);
-          ConsumeToken();
-          if (CurrentToken() != Token::kINTERPOL_END) {
-            ErrorMsg("'}' expected");
-          }
-          ConsumeToken();
-        } else {
-          ErrorMsg("identifier expected");
-        }
-      } else {
-        ASSERT(CurrentToken() == Token::kINTERPOL_VAR);
-        resolved_name = ResolveImportVar(TokenPos(), *CurrentLiteral());
-        result = String::Concat(result, resolved_name);
-        ConsumeToken();
-      }
-    }
-    // A string literal always ends with a kSTRING token.
-    ASSERT(CurrentToken() == Token::kSTRING);
-  }
-  return &result;
-}
-
-
 AstNode* Parser::ParseArgumentDefinitionTest() {
   const intptr_t test_pos = TokenPos();
   ConsumeToken();
   const intptr_t ident_pos = TokenPos();
   String* ident = ExpectIdentifier("parameter name expected");
   Function& owner_function = Function::Handle();
   LocalScope* owner_scope;
   intptr_t param_index;
   if (!IsFormalParameter(*ident, &owner_function, &owner_scope, &param_index)) {
     ErrorMsg(ident_pos, "formal parameter name expected");
@@ skipping 460 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart