Update handling of ambiguous name references

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 1682 matching lines @@
 // Lookup class in the core lib which also contains various VM
 // helper methods and classes. Allow look up of private classes.
 static RawClass* LookupCoreClass(const String& class_name) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = Symbols::New(name);
   }
-  return core_lib.LookupClass(name, NULL);  // No ambiguity error expected.
+  return core_lib.LookupClass(name);
 }
 
 
 static const String& PrivateCoreLibName(const String& str) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
   return private_name;
 }
 
 
@@ skipping 6731 matching lines @@
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // The referenced class may not have been parsed yet. It would be wrong
       // to resolve it too early to an imported class of the same name.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         // Resolve classname in the scope of the current library.
-        Error& error = Error::Handle();
         resolved_type_class = ResolveClassInCurrentLibraryScope(
-            unresolved_class.token_pos(),
-            unresolved_class_name,
-            &error);
-        if (!error.IsNull()) {
-          if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-              FLAG_error_on_bad_type) {
-            *type = ClassFinalizer::NewFinalizedMalformedType(
-                error,
-                scope_class,
-                unresolved_class.token_pos(),
-                "cannot resolve class '%s'",
-                unresolved_class_name.ToCString());
-          } else {
-            // Map the malformed type to dynamic and ignore type arguments.
-            *type = Type::DynamicType();
-          }
-          return;
-        }
+            unresolved_class_name);
       }
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
-      Error& error = Error::Handle();
-      resolved_type_class = ResolveClassInPrefixScope(
-          unresolved_class.token_pos(),
-          lib_prefix,
-          unresolved_class_name,
-          &error);
-      if (!error.IsNull()) {
-        if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-            FLAG_error_on_bad_type) {
-          *type = ClassFinalizer::NewFinalizedMalformedType(
-              error,
-              scope_class,
-              unresolved_class.token_pos(),
-              "cannot resolve class '%s'",
-              unresolved_class_name.ToCString());
-        } else {
-          // Map the malformed type to dynamic and ignore type arguments.
-          *type = Type::DynamicType();
-        }
-        return;
-      }
+      resolved_type_class =
+          ResolveClassInPrefixScope(lib_prefix, unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     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) {
       if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
           FLAG_error_on_bad_type) {
         ClassFinalizer::FinalizeMalformedType(
@@ skipping 367 matching lines @@
   obj = lib.LookupLocalObject(accessor_name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
   accessor_name = Field::SetterName(name);
   obj = lib.LookupLocalObject(accessor_name);
   return obj.raw();
 }
 
 
-static RawObject* LookupNameInImport(Isolate* isolate,
-                                     const Namespace& ns,
-                                     const String& name) {
-  // If the given name is filtered out by the import, don't look it up, nor its
-  // getter and setter names.
-  if (ns.HidesName(name)) {
-    return Object::null();
-  }
-  Object& obj = Object::Handle(isolate);
-  obj = ns.Lookup(name);
-  if (!obj.IsNull()) {
-    return obj.raw();
-  }
-  String& accessor_name = String::Handle(isolate, Field::GetterName(name));
-  obj = ns.Lookup(accessor_name);
-  if (!obj.IsNull()) {
-    return obj.raw();
-  }
-  accessor_name = Field::SetterName(name);
-  obj = ns.Lookup(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,
-                                                    Error* error) {
+RawObject* Parser::ResolveNameInCurrentLibraryScope(const String& name) {
   TRACE_PARSER("ResolveNameInCurrentLibraryScope");
   HANDLESCOPE(isolate());
   Object& obj = Object::Handle(isolate(),
                                LookupNameInLibrary(isolate(), library_, name));
-  if (obj.IsNull()) {
-    // Name is not found in current library. Check scope of all
-    // imported libraries.
-    String& first_lib_url = String::Handle(isolate());
-    Namespace& import = Namespace::Handle(isolate());
-    intptr_t num_imports = library_.num_imports();
-    Object& imported_obj = Object::Handle(isolate());
-    Library& lib = Library::Handle(isolate());
-    for (int i = 0; i < num_imports; i++) {
-      import = library_.ImportAt(i);
-      imported_obj = LookupNameInImport(isolate(), import, name);
-      if (!imported_obj.IsNull()) {
-        lib ^= import.library();
-        if (!first_lib_url.IsNull()) {
-          // Found duplicate definition.
-          Error& ambiguous_ref_error = Error::Handle();
-          if (first_lib_url.raw() == lib.url()) {
-            ambiguous_ref_error = FormatErrorMsg(
-                script_, ident_pos, "Error",
-                "ambiguous reference to '%s', "
-                "as library '%s' is imported multiple times",
-                name.ToCString(),
-                first_lib_url.ToCString());
-          } else {
-            ambiguous_ref_error = FormatErrorMsg(
-                script_, ident_pos, "Error",
-                "ambiguous reference: "
-                "'%s' is defined in library '%s' and also in '%s'",
-                name.ToCString(),
-                first_lib_url.ToCString(),
-                String::Handle(lib.url()).ToCString());
-          }
-          if (error == NULL) {
-            // Report a compile time error since the caller is not interested
-            // in the error.
-            ErrorMsg(ambiguous_ref_error);
-          }
-          *error = ambiguous_ref_error.raw();
-          return Object::null();
-        } else {
-          first_lib_url = lib.url();
-          obj = imported_obj.raw();
-        }
-      }
-    }
+  if (!obj.IsNull()) {
+    return obj.raw();
   }
-  return obj.raw();
+  return library_.LookupImportedObject(name);
 }
 
 
-RawClass* Parser::ResolveClassInCurrentLibraryScope(intptr_t ident_pos,
-                                                    const String& name,
-                                                    Error* error) {
+RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
   const Object& obj =
-      Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, name, error));
+      Object::Handle(ResolveNameInCurrentLibraryScope(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, NULL));
+    Object::Handle(ResolveNameInCurrentLibraryScope(ident));
   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());
     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());
   }
   // 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,
-                                            Error* error) {
-  TRACE_PARSER("ResolveNameInPrefixScope");
+RawObject* Parser::ResolveNameInPrefixScope(const LibraryPrefix& prefix,
+                                            const String& name) {
   HANDLESCOPE(isolate());
-  Namespace& import = Namespace::Handle(isolate());
-  String& first_lib_url = String::Handle(isolate());
-  Object& obj = Object::Handle(isolate());
-  Object& resolved_obj = Object::Handle(isolate());
-  const Array& imports = Array::Handle(isolate(), prefix.imports());
-  Library& lib = Library::Handle(isolate());
-  for (intptr_t i = 0; i < prefix.num_imports(); i++) {
-    import ^= imports.At(i);
-    resolved_obj = LookupNameInImport(isolate(), import, name);
-    if (!resolved_obj.IsNull()) {
-      obj = resolved_obj.raw();
-      lib = import.library();
-      if (first_lib_url.IsNull()) {
-        first_lib_url = lib.url();
-      } else {
-        // Found duplicate definition.
-        Error& ambiguous_ref_error = Error::Handle();
-        if (first_lib_url.raw() == lib.url()) {
-          ambiguous_ref_error = FormatErrorMsg(
-              script_, ident_pos, "Error",
-              "ambiguous reference: '%s.%s' is imported multiple times",
-              String::Handle(prefix.name()).ToCString(),
-              name.ToCString());
-        } else {
-          ambiguous_ref_error = FormatErrorMsg(
-              script_, ident_pos, "Error",
-              "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());
-        }
-        if (error == NULL) {
-          // Report a compile time error since the caller is not interested
-          // in the error.
-          ErrorMsg(ambiguous_ref_error);
-        }
-        *error = ambiguous_ref_error.raw();
-        return Object::null();
-      }
-    }
-  }
-  return obj.raw();
+  return prefix.LookupObject(name);
 }
 
 
-RawClass* Parser::ResolveClassInPrefixScope(intptr_t ident_pos,
-                                            const LibraryPrefix& prefix,
-                                            const String& name,
-                                            Error* error) {
+RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
+                                            const String& name) {
   const Object& obj =
-      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, name, error));
+      Object::Handle(ResolveNameInPrefixScope(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, NULL));
+  Object& obj = Object::Handle(ResolveNameInPrefixScope(prefix, ident));
   if (obj.IsNull()) {
     // 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()) {
@@ skipping 1442 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart