Implement import scope

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 2906 matching lines @@
   const intptr_t class_pos = TokenPos();
   bool is_patch = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   }
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = TokenPos();
-  String& class_name = *ExpectTypeIdentifier("class name expected");
+  String& class_name = *ExpectClassIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle();
-  Object& obj = Object::Handle(library_.LookupObject(class_name));
+  Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
       ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
                class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
@@ skipping 78 matching lines @@
   cls.SetFields(array);
 
   // Creating a new array for functions marks the class as parsed.
   array = Array::MakeArray(members.functions());
   cls.SetFunctions(array);
 
   if (!is_patch) {
     pending_classes.Add(cls, Heap::kOld);
   } else {
     // Lookup the patched class and apply the changes.
-    obj = library_.LookupObject(class_name);
+    obj = library_.LookupLocalObject(class_name);
     const char* err_msg = Class::Cast(obj).ApplyPatch(cls);
     if (err_msg != NULL) {
       ErrorMsg(classname_pos, "applying patch failed with '%s'", err_msg);
     }
   }
 }
 
 
 // Add an implicit constructor if no explicit constructor is present.
 void Parser::AddImplicitConstructor(ClassDesc* class_desc) {
@@ skipping 100 matching lines @@
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in unchecked mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = TokenPos();
   const String* alias_name =
-      ExpectTypeIdentifier("function alias name expected");
+      ExpectClassIdentifier("function alias name expected");
 
   // Parse the type parameters of the function type.
   ParseTypeParameters(alias_owner);
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(alias_owner,
                          ClassFinalizer::kTryResolve,
                          &result_type);
   }
@@ skipping 33 matching lines @@
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
   } else {
     // Forget the just created signature function and use the existing one.
     signature_function = signature_class.signature_function();
   }
   ASSERT(signature_function.signature_class() == signature_class.raw());
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
-  const Object& obj = Object::Handle(library_.LookupObject(*alias_name));
+  const Object& obj = Object::Handle(library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ErrorMsg(alias_name_pos,
              "'%s' is already defined", alias_name->ToCString());
   }
 
   // Create the function type alias, but share the signature function of the
   // canonical signature class.
   Class& function_type_alias = Class::Handle(
       Class::NewSignatureClass(*alias_name,
                                signature_function,
                                script_));
   // This alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
   ASSERT(!function_type_alias.IsCanonicalSignatureClass());
   ASSERT(!function_type_alias.is_finalized());
   library_.AddClass(function_type_alias);
   ExpectSemicolon();
   pending_classes.Add(function_type_alias, Heap::kOld);
 }
 
 
 void Parser::ParseInterfaceDefinition(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
   const intptr_t interface_pos = TokenPos();
   ExpectToken(Token::kINTERFACE);
   const intptr_t interfacename_pos = TokenPos();
-  String& interface_name = *ExpectTypeIdentifier("interface name expected");
+  String& interface_name = *ExpectClassIdentifier("interface name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
   }
   Class& interface = Class::Handle();
-  Object& obj = Object::Handle(library_.LookupObject(interface_name));
+  Object& obj = Object::Handle(library_.LookupLocalObject(interface_name));
   if (obj.IsNull()) {
     interface = Class::NewInterface(interface_name, script_, interfacename_pos);
     library_.AddClass(interface);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(interfacename_pos, "'%s' is already defined",
                interface_name.ToCString());
     }
     interface ^= obj.raw();
     if (!interface.is_interface()) {
@@ skipping 323 matching lines @@
   const AbstractType& type =
       AbstractType::ZoneHandle(ParseConstFinalVarOrType(
           FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
                                     ClassFinalizer::kIgnore));
   Field& field = Field::Handle();
   Function& getter = Function::Handle();
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
-    if (library_.LookupObject(var_name) != Object::null()) {
+    if (library_.LookupLocalObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
-    if (library_.LookupObject(accessor_name) != Object::null()) {
+    if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
-    if (library_.LookupObject(accessor_name) != Object::null()) {
+    if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
     field = Field::New(
          var_name, is_static, is_final, is_const, current_class(), name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
@@ skipping 59 matching lines @@
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kTryResolve);
     }
   }
   const intptr_t name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
-  bool found = library_.LookupObject(func_name) != Object::null();
+  bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
   }
   String& accessor_name = String::Handle(Field::GetterName(func_name));
-  if (library_.LookupObject(accessor_name) != Object::null()) {
+  if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as getter",
              func_name.ToCString());
   }
   accessor_name = Field::SetterName(func_name);
-  if (library_.LookupObject(accessor_name) != Object::null()) {
+  if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as setter",
              func_name.ToCString());
   }
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
@@ skipping 88 matching lines @@
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
   if ((params.num_fixed_parameters != expected_num_parameters) ||
       (params.num_optional_parameters != 0)) {
     ErrorMsg(name_pos, "illegal %s parameters",
              is_getter ? "getter" : "setter");
   }
 
-  if (library_.LookupObject(*field_name) != Object::null()) {
+  if (library_.LookupLocalObject(*field_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined in this library",
              field_name->ToCString());
   }
-  bool found = library_.LookupObject(accessor_name) != Object::null();
+  bool found = library_.LookupLocalObject(accessor_name) != Object::null();
   if (found && !is_patch) {
     ErrorMsg(name_pos, "%s for '%s' is already defined",
              is_getter ? "getter" : "setter",
              field_name->ToCString());
   } else if (!found && is_patch) {
     ErrorMsg(name_pos, "missing %s for '%s' cannot be patched",
              is_getter ? "getter" : "setter",
              field_name->ToCString());
   }
 
@@ skipping 216 matching lines @@
       ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(pending_classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
       ParseInterfaceDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ConsumeToken();  // Consume and ignore 'abstract'.
       ParseClassDefinition(pending_classes);
-    } else if (is_patch_source() &&
-               (CurrentToken() == Token::kIDENT) &&
-               CurrentLiteral()->Equals("patch") &&
+    } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDefinition(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
       } else if (IsFunctionDeclaration()) {
         ParseTopLevelFunction(&top_level);
       } else if (IsTopLevelAccessor()) {
         ParseTopLevelAccessor(&top_level);
@@ skipping 2182 matching lines @@
 }
 
 
 void Parser::UnexpectedToken() {
   ErrorMsg("unexpected token '%s'",
            CurrentToken() == Token::kIDENT ?
                CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
 }
 
 
-String* Parser::ExpectTypeIdentifier(const char* msg) {
+String* Parser::ExpectClassIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg(msg);
   }
   String* ident = CurrentLiteral();
+  if (ident->Equals("Dynamic")) {
+    ErrorMsg(msg);
+  }
   ConsumeToken();
   return ident;
 }
 
+
 // Check whether current token is an identifier or a built-in identifier.
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
     ErrorMsg(msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
@@ skipping 993 matching lines @@
           // type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
             ErrorMsg(type_parameter.token_pos(),
                      "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.name()).ToCString());
           }
           *type = type_parameter.raw();
           return;
         }
       }
-      // Global lookup in current library.
-      resolved_type_class = library_.LookupClass(unresolved_class_name);
+      // Resolve classname in the scope of the current library.
+      resolved_type_class =
+          ResolveClassInCurrentLibraryScope(unresolved_class.token_pos(),
+                                            unresolved_class_name);
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
-      // Local lookup in library prefix scope.
-      resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);
+      // Resolve class name in the scope of the library prefix.
+      resolved_type_class =
+          ResolveClassInPrefixScope(unresolved_class.token_pos(),
+                                   lib_prefix,
+                                   unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
@@ skipping 335 matching lines @@
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;  // Not an unqualified identifier.
 }
 
 
-// Do a lookup for the identifier in the library scope of the specified
-// library. If resolve_locally is true the lookup does not consider
-// the libraries imported by it for the lookup.
-AstNode* Parser::ResolveIdentInLibraryScope(const Library& lib,
-                                            const QualIdent& qual_ident,
-                                            bool resolve_locally) {
-  TRACE_PARSER("ResolveIdentInLibraryScope");
+static RawObject* LookupNameInLibrary(const Library& lib, const String& name) {
   Object& obj = Object::Handle();
-  if (resolve_locally) {
-    obj = lib.LookupLocalObject(*qual_ident.ident);
-  } else {
-    obj = lib.LookupObject(*qual_ident.ident);
-  }
+  obj = lib.LookupLocalObject(name);
+  if (!obj.IsNull()) {
+    return obj.raw();
+  }
+  String& accessor_name = String::Handle(Field::GetterName(name));
+  obj = lib.LookupLocalObject(accessor_name);
+  if (!obj.IsNull()) {
+    return obj.raw();
+  }
+  accessor_name = Field::SetterName(name);
+  obj = lib.LookupLocalObject(accessor_name);
+  return obj.raw();
+}
+
+
+// Resolve a name by checking the global scope of the current
+// library. If not found in the current library, then look in the scopes
+// of all libraries that are imported without a library prefix.
+// Issue an error if the name is not found in the global scope
+// of the current library, but is defined in more than one imported
+// library, i.e. if the name cannot be resolved unambiguously.
+RawObject* Parser::ResolveNameInCurrentLibraryScope(intptr_t ident_pos,
+                                                    const String& name) {
+  TRACE_PARSER("ResolveNameInCurrentLibraryScope");
+  Object& obj = Object::Handle(LookupNameInLibrary(library_, name));
+  if (obj.IsNull()) {
+    // Name is not found in current library. Check scope of all
+    // imported libraries.
+    String& first_lib_url = String::Handle();
+    Library& lib = Library::Handle();
+    intptr_t num_imports = library_.num_imports();
+    Object& resolved_obj = Object::Handle();
+    for (int i = 0; i < num_imports; i++) {
+      lib ^= library_.ImportAt(i);
+      resolved_obj = LookupNameInLibrary(lib, name);
+      if (!resolved_obj.IsNull()) {
+        if (!first_lib_url.IsNull()) {
+          // Found duplicate definition.
+          ErrorMsg(ident_pos,
+                   "ambiguous reference: "
+                   "'%s' is defined in library '%s' and also in '%s'",
+                   name.ToCString(),
+                   first_lib_url.ToCString(),
+                   String::Handle(lib.url()).ToCString());
+        } else {
+          first_lib_url = lib.url();
+          obj = resolved_obj.raw();
+        }
+      }
+    }
+  }
+  return obj.raw();
+}
+
+
+RawClass* Parser::ResolveClassInCurrentLibraryScope(intptr_t ident_pos,
+                                                    const String& name) {
+  const Object& obj =
+      Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, name));
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  return Class::null();
+}
+
+
+// Resolve an identifier by checking the global scope of the current
+// library. If not found in the current library, then look in the scopes
+// of all libraries that are imported without a library prefix.
+// Issue an error if the identifier is not found in the global scope
+// of the current library, but is defined in more than one imported
+// library, i.e. if the identifier cannot be resolved unambiguously.
+AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
+                                                   const String& ident) {
+  TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
+  const Object& obj =
+    Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    return new PrimaryNode(qual_ident.ident_pos, Class::ZoneHandle(cls.raw()));
-  }
-  if (obj.IsField()) {
+    return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+  } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
-    return GenerateStaticFieldLookup(field, qual_ident.ident_pos);
-  }
-  if (obj.IsFunction()) {
+    return GenerateStaticFieldLookup(field, ident_pos);
+  } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
-    return new PrimaryNode(qual_ident.ident_pos,
-                           Function::ZoneHandle(func.raw()));
+    if (func.IsGetterFunction() || func.IsSetterFunction()) {
+      return new StaticGetterNode(ident_pos,
+                                  /* receiver */ NULL,
+                                  /* is_super_getter */ false,
+                                  Class::ZoneHandle(func.Owner()),
+                                  ident);
+
+    } else {
+      return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+    }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
-
-  // Check if there is a global getter or setter for qual_ident.
-  // We create a getter node even if a getter doesn't exist since
-  // qual_ident could be followed by an assignment which will convert it
-  // to a setter node. If there is no assignment we will get an error
-  // when we try to invoke the getter.
-  String& accessor_name = String::Handle(Field::GetterName(*qual_ident.ident));
-  if (resolve_locally) {
-    obj = lib.LookupLocalObject(accessor_name);
-  } else {
-    obj = lib.LookupObject(accessor_name);
-  }
+  // Lexically unresolved primary identifiers are referenced by their name.
+  return new PrimaryNode(ident_pos, ident);
+}
+
+
+RawObject* Parser::ResolveNameInPrefixScope(intptr_t ident_pos,
+                                            const LibraryPrefix& prefix,
+                                            const String& name) {
+  TRACE_PARSER("ResolveNameInPrefixScope");
+  Library& lib = Library::Handle();
+  String& first_lib_url = String::Handle();
+  Object& obj = Object::Handle();
+  Object& resolved_obj = Object::Handle();
+  for (intptr_t i = 0; i < prefix.num_libs(); i++) {
+    lib = prefix.GetLibrary(i);
+    ASSERT(!lib.IsNull());
+    resolved_obj = LookupNameInLibrary(lib, name);
+    if (!resolved_obj.IsNull()) {
+      obj = resolved_obj.raw();
+      if (first_lib_url.IsNull()) {
+        first_lib_url = lib.url();
+      } else {
+        ErrorMsg(ident_pos,
+                 "ambiguous reference: '%s.%s' is defined in '%s' and '%s'",
+                 String::Handle(prefix.name()).ToCString(),
+                 name.ToCString(),
+                 first_lib_url.ToCString(),
+                 String::Handle(lib.url()).ToCString());
+      }
+    }
+  }
+  return obj.raw();
+}
+
+
+RawClass* Parser::ResolveClassInPrefixScope(intptr_t ident_pos,
+                                            const LibraryPrefix& prefix,
+                                            const String& name) {
+  const Object& obj =
+      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, name));
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  return Class::null();
+}
+
+
+// Do a lookup for the identifier in the scope of the specified
+// library prefix. This means trying to resolve it locally in all of the
+// libraries present in the library prefix. If there are multiple libraries
+// with the name, issue an ambiguous reference error.
+AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
+                                           const LibraryPrefix& prefix,
+                                           const String& ident) {
+  TRACE_PARSER("ResolveIdentInPrefixScope");
+  Object& obj =
+      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, ident));
   if (obj.IsNull()) {
-    accessor_name = Field::SetterName(*qual_ident.ident);
-    if (resolve_locally) {
-      obj = lib.LookupLocalObject(accessor_name);
-    } else {
-      obj = lib.LookupObject(accessor_name);
-    }
-  }
-  if (!obj.IsNull()) {
-    ASSERT(obj.IsFunction());
+    // Unresolved prefixed primary identifier.
+    ErrorMsg(ident_pos, "identifier '%s.%s' cannot be resolved",
+             String::Handle(prefix.name()).ToCString(),
+             ident.ToCString());
+  }
+  if (obj.IsClass()) {
+    const Class& cls = Class::Cast(obj);
+    return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+  } else if (obj.IsField()) {
+    const Field& field = Field::Cast(obj);
+    ASSERT(field.is_static());
+    return GenerateStaticFieldLookup(field, ident_pos);
+  } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
-    ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
-    return new StaticGetterNode(qual_ident.ident_pos,
-                                NULL,
-                                false,
-                                Class::ZoneHandle(func.Owner()),
-                                *qual_ident.ident);
-  }
-  if (qual_ident.lib_prefix != NULL) {
-    return NULL;
+    if (func.IsGetterFunction() || func.IsSetterFunction()) {
+      return new StaticGetterNode(ident_pos,
+                                  /* receiver */ NULL,
+                                  /* is_super_getter */ false,
+                                  Class::ZoneHandle(func.Owner()),
+                                  ident);
+
+    } else {
+      return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+    }
+  } else {
+    // TODO(hausner): Should this be an error? It is not meaningful to
+    // reference a library prefix defined in an imported library.
+    ASSERT(obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
-  return new PrimaryNode(qual_ident.ident_pos, *qual_ident.ident);
-}
-
-
-// Do a lookup for the identifier in the library prefix scope of the specified
-// library prefix. This would mean trying to resolve it locally in any of the
-// libraries present in the library prefix.
-AstNode* Parser::ResolveIdentInLibraryPrefixScope(const LibraryPrefix& prefix,
-                                                  const QualIdent& qual_ident) {
-  TRACE_PARSER("ResolveIdentInLibraryPrefixScope");
-  Library& lib = Library::Handle();
-  AstNode* result = NULL;
-  for (intptr_t i = 0; ((i < prefix.num_libs()) && (result == NULL)); i++) {
-    lib = prefix.GetLibrary(i);
-    ASSERT(!lib.IsNull());
-    result = ResolveIdentInLibraryScope(lib, qual_ident, kResolveLocally);
-  }
-  if (result == NULL) {
-    // This is an unresolved prefixed primary identifier, need to report
-    // an error.
-    ErrorMsg(qual_ident.ident_pos, "identifier '%s.%s' cannot be resolved",
-             String::Handle(qual_ident.lib_prefix->name()).ToCString(),
-             qual_ident.ident->ToCString());
-  }
-  return result;
+  return new PrimaryNode(ident_pos, ident);
 }
 
 
 // Resolve identifier, issue an error message if the name refers to
 // a class/interface or a type parameter. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or issue an error message
 // if we're compiling a static method.
 AstNode* Parser::ResolveIdent(intptr_t ident_pos,
@@ skipping 12 matching lines @@
       TypeParameter& type_param = TypeParameter::Handle(
           scope_class.LookupTypeParameter(ident, ident_pos));
       if (!type_param.IsNull()) {
         String& type_param_name = String::Handle(type_param.name());
         ErrorMsg(ident_pos, "illegal use of type parameter %s",
                  type_param_name.ToCString());
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
-    // and all libraries imported by it).
-    QualIdent qual_ident;
-    qual_ident.lib_prefix = NULL;
-    qual_ident.ident_pos = ident_pos;
-    qual_ident.ident = &(String::ZoneHandle(ident.raw()));
-    resolved = ResolveIdentInLibraryScope(library_,
-                                              qual_ident,
-                                              kResolveIncludingImports);
+    // and all libraries imported by it without a library prefix).
+    resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // method, this is an error. In an instance method, we convert
       // the unresolved name to an instance field access, since a
       // subclass might define a field with this name.
       if (current_function().is_static()) {
         ErrorMsg(ident_pos, "identifier '%s' is not declared in this scope",
@@ skipping 937 matching lines @@
           if (!type_param.IsNull()) {
             const String& type_param_name = String::Handle(type_param.name());
             ErrorMsg(qual_ident.ident_pos,
                      "illegal use of type parameter %s",
                      type_param_name.ToCString());
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
-        primary = ResolveIdentInLibraryScope(library_,
-                                             qual_ident,
-                                             kResolveIncludingImports);
+        primary = ResolveIdentInCurrentLibraryScope(qual_ident.ident_pos,
+                                                    *qual_ident.ident);
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
-      primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
-                                                 qual_ident);
+      primary = ResolveIdentInPrefixScope(qual_ident.ident_pos,
+                                          *qual_ident.lib_prefix,
+                                          *qual_ident.ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     const String& this_name = String::Handle(Symbols::This());
     LocalVariable* local = LookupLocalScope(this_name);
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
     primary = new LoadLocalNode(TokenPos(), local);
     ConsumeToken();
@@ skipping 355 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart