Implement support for specifying string interopolation style variable substitution in the import ...

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 3206 matching lines @@
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     library_.SetName(name);
   }
 }
 
 
 Dart_Handle Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                           intptr_t token_pos,
-                                          const String& url) {
+                                          const String& url,
+                                          const Array& import_map) {
   Dart_LibraryTagHandler handler = Isolate::Current()->library_tag_handler();
   if (handler == NULL) {
     ErrorMsg(token_pos, "no library handler registered");
   }
   Dart_Handle result = handler(tag,
                                Api::NewLocalHandle(library_),
-                               Api::NewLocalHandle(url));
+                               Api::NewLocalHandle(url),
+                               Api::NewLocalHandle(import_map));
   if (Dart_IsError(result)) {
     ErrorMsg(token_pos, "library handler failed: %s", Dart_GetError(result));
   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
   while (CurrentToken() == Token::kIMPORT) {
     const intptr_t import_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
-    const String& url = *CurrentLiteral();
-    ConsumeToken();
+    const String& url = *ParseImportStringLiteral();
     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");
       }
       prefix = CurrentLiteral()->raw();
       // TODO(asiva): Need to also check that prefix is not a reserved keyword.
       if (!Scanner::IsIdent(prefix)) {
         ErrorMsg("prefix should be an identifier");
       }
       ConsumeToken();
     }
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
+    const Array& import_map = Array::Handle(library_.import_map());
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                import_pos,
-                                               url);
+                                               url,
+                                               import_map);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     // Lookup the library URL.
     Library& library = Library::Handle(Library::LookupLibrary(canon_url));
     if (library.IsNull()) {
       // Call the library tag handler to load the library.
-      CallLibraryTagHandler(kImportTag, import_pos, canon_url);
+      CallLibraryTagHandler(kImportTag, import_pos, canon_url, import_map);
       // If the library tag handler succeded without registering the
       // library we create an empty library to import.
       library = Library::LookupLibrary(canon_url);
       if (library.IsNull()) {
         library = Library::New(canon_url);
         library.Register();
       }
     }
     // Add the import to the library.
     if (prefix.IsNull() || (prefix.Length() == 0)) {
       library_.AddImport(library);
     } else {
       if (library_.LookupLocalObject(prefix) != Object::null()) {
         ErrorMsg(token_index_, "'%s' is already defined", prefix.ToCString());
       }
       const LibraryPrefix& library_prefix =
           LibraryPrefix::Handle(LibraryPrefix::New(prefix, library));
       library_.AddObject(library_prefix, prefix);
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
+  const Array& import_map = Array::Handle(library_.import_map());
   while (CurrentToken() == Token::kSOURCE) {
     const intptr_t source_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
-    const String& url = *CurrentLiteral();
-    ConsumeToken();
+    const String& url = *ParseImportStringLiteral();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
-                                               url);
+                                               url,
+                                               import_map);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
-    CallLibraryTagHandler(kSourceTag, source_pos, canon_url);
+    CallLibraryTagHandler(kSourceTag, source_pos, canon_url, import_map);
   }
 }
 
 
 void Parser::ParseLibraryDefinition() {
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
@@ skipping 3308 matching lines @@
     } else {
       ASSERT(primary->primary().IsClass());
       ErrorMsg(ident_pos, "illegal reference to class or interface '%s'",
                ident.ToCString());
     }
   }
   return var_or_field;
 }
 
 
+// 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");
+  String& map_name = String::Handle(library_.LookupImportMap(ident));
+  if (!map_name.IsNull()) {
+    return map_name.raw();
+  }
+  ErrorMsg(ident_pos, "import variable '%s' has not been defined",
+           ident.ToCString());
+  return String::null();
+}
+
+
 // Parses type = [ident "."] ident ["<" type { "," type } ">"].
 // Returns the class object if the type can be resolved. Otherwise, either give
 // an error if type resolution was required, or return the unresolved name as a
 // string object.
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   if (type_resolution == kIgnore) {
@@ skipping 657 matching lines @@
   if ((CurrentToken() == Token::kSTRING) &&
       (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
       (LookaheadToken(1) != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   ArrayNode* values = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
-  GrowableArray<const Object*> arg_values;
   while (CurrentToken() == Token::kSTRING) {
     values->AddElement(new LiteralNode(token_index_, *CurrentLiteral()));
     ConsumeToken();
     if ((CurrentToken() != Token::kINTERPOL_VAR) &&
         (CurrentToken() != Token::kINTERPOL_START)) {
       break;
     }
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
@@ skipping 15 matching lines @@
   ArgumentListNode* interpolate_arg =
       new ArgumentListNode(values->token_index());
   interpolate_arg->Add(values);
   primary = MakeStaticCall(kStringClassName,
                            kInterpolateName,
                            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() {
+  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(String::New(""));
+  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(token_index_, *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(token_index_, *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::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
@@ skipping 388 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart