Revert my last change.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 3508 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) {
   Isolate* isolate = Isolate::Current();
   Dart_LibraryTagHandler handler = isolate->library_tag_handler();
   if (handler == NULL) {
     ErrorMsg(token_pos, "no library handler registered");
   }
   Dart_Handle result = handler(tag,
                                Api::NewHandle(isolate, library_.raw()),
-                               Api::NewHandle(isolate, url.raw()));
+                               Api::NewHandle(isolate, url.raw()),
+                               Api::NewHandle(isolate, import_map.raw()));
   if (Dart_IsError(result)) {
     Error& prev_error = Error::Handle();
     prev_error ^= Api::UnwrapHandle(result);
     AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
@@ skipping 19 matching lines @@
       }
       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 {
       LibraryPrefix& library_prefix = LibraryPrefix::Handle();
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
         library_prefix.AddLibrary(library);
       } else {
         library_prefix = LibraryPrefix::New(prefix, library);
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
   TRACE_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 = *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::ParseLibraryResource() {
   TRACE_PARSER("ParseLibraryResource");
   while (CurrentToken() == Token::kRESOURCE) {
     // Currently the VM does ignore #resource library tags. They are only used
     // by the IDE.
     ConsumeToken();
@@ skipping 3549 matching lines @@
   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");
-  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;
-    }
+  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 } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
@@ skipping 1247 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart