Update handling of ambiguous name references

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 151 matching lines @@
   V(CoreLibrary, int, _parse)                                                  \
   V(CoreLibrary, StackTrace, _setupFullStackTrace)                             \
   V(CoreLibrary, _OneByteString, _setAt)                                       \
 
 
 static void MarkFunctionAsInvisible(const Library& lib,
                                     const char* class_name,
                                     const char* function_name) {
   ASSERT(!lib.IsNull());
   const Class& cls = Class::Handle(
-      lib.LookupClassAllowPrivate(String::Handle(String::New(class_name)),
-                                  NULL));  // No ambiguity error expected.
+      lib.LookupClassAllowPrivate(String::Handle(String::New(class_name))));
   ASSERT(!cls.IsNull());
   const Function& function =
       Function::Handle(
           cls.LookupFunctionAllowPrivate(
               String::Handle(String::New(function_name))));
   ASSERT(!function.IsNull());
   function.set_is_visible(false);
 }
 
 
@@ skipping 2032 matching lines @@
     signature_function.set_signature_class(*this);
     ASSERT(IsCanonicalSignatureClass());
   }
   set_is_prefinalized();
 }
 
 
 RawClass* Class::NewNativeWrapper(const Library& library,
                                   const String& name,
                                   int field_count) {
-  String& ambiguity_error_msg = String::Handle();
-  Class& cls = Class::Handle(library.LookupClass(name, &ambiguity_error_msg));
+  Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
-    if (!ambiguity_error_msg.IsNull()) {
-      return Class::null();
-    }
     cls = New(name, Script::Handle(), Scanner::kDummyTokenIndex);
     cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
     intptr_t instance_size = sizeof(RawObject) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
@@ skipping 4486 matching lines @@
     GrowDictionary(dict, dict_size);
   }
 
   // Invalidate the cache of loaded scripts.
   if (loaded_scripts() != Array::null()) {
     StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
   }
 }
 
 
-// Lookup a name in the library's export namespace.
-RawObject* Library::LookupExport(const String& name) const {
+// Lookup a name in the library's re-export namespace. The name is
+// unmangled, i.e. no getter or setter names should be looked up.
+RawObject* Library::LookupReExport(const String& name) const {
   if (HasExports()) {
     const Array& exports = Array::Handle(this->exports());
     // Break potential export cycle while looking up name.
     StorePointer(&raw_ptr()->exports_, Object::empty_array().raw());
     Namespace& ns = Namespace::Handle();
     Object& obj = Object::Handle();
     for (int i = 0; i < exports.Length(); i++) {
       ns ^= exports.At(i);
       obj = ns.Lookup(name);
       if (!obj.IsNull()) {
@@ skipping 157 matching lines @@
        name.CharAt(0) == '_') ||
       (name.Length() >= 5 &&
        (name.CharAt(4) == '_' &&
         (name.CharAt(0) == 'g' || name.CharAt(0) == 's') &&
         name.CharAt(1) == 'e' &&
         name.CharAt(2) == 't' &&
         name.CharAt(3) == ':'));
 }
 
 
-RawField* Library::LookupFieldAllowPrivate(const String& name,
-                                           String* ambiguity_error_msg) const {
-  Object& obj = Object::Handle(
-      LookupObjectAllowPrivate(name, ambiguity_error_msg));
+RawField* Library::LookupFieldAllowPrivate(const String& name) const {
+  Object& obj = Object::Handle(LookupObjectAllowPrivate(name));
   if (obj.IsField()) {
     return Field::Cast(obj).raw();
   }
   return Field::null();
 }
 
 
 RawField* Library::LookupLocalField(const String& name) const {
   Object& obj = Object::Handle(LookupLocalObjectAllowPrivate(name));
   if (obj.IsField()) {
     return Field::Cast(obj).raw();
   }
   return Field::null();
 }
 
 
-RawFunction* Library::LookupFunctionAllowPrivate(
-    const String& name,
-    String* ambiguity_error_msg) const {
-  Object& obj = Object::Handle(
-      LookupObjectAllowPrivate(name, ambiguity_error_msg));
+RawFunction* Library::LookupFunctionAllowPrivate(const String& name) const {
+  Object& obj = Object::Handle(LookupObjectAllowPrivate(name));
   if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
   }
   return Function::null();
 }
 
 
 RawFunction* Library::LookupLocalFunction(const String& name) const {
   Object& obj = Object::Handle(LookupLocalObjectAllowPrivate(name));
   if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
   }
   return Function::null();
 }
 
 
 RawObject* Library::LookupLocalObjectAllowPrivate(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Object& obj = Object::Handle(isolate, Object::null());
   obj = LookupLocalObject(name);
   if (obj.IsNull() && ShouldBePrivate(name)) {
     String& private_name = String::Handle(isolate, PrivateName(name));
     obj = LookupLocalObject(private_name);
   }
   return obj.raw();
 }
 
 
-RawObject* Library::LookupObjectAllowPrivate(
-    const String& name,
-    String* ambiguity_error_msg) const {
+RawObject* Library::LookupObjectAllowPrivate(const String& name) const {
   // First check if name is found in the local scope of the library.
   Object& obj = Object::Handle(LookupLocalObjectAllowPrivate(name));
   if (!obj.IsNull()) {
     return obj.raw();
   }
 
   // Do not look up private names in imported libraries.
   if (ShouldBePrivate(name)) {
     return Object::null();
   }
 
-  // Now check if name is found in any imported libs. It is a compile-time error
-  // if the name is found in more than one import and actually used.
-  return LookupImportedObject(name, ambiguity_error_msg);
+  // Now check if name is found in any imported libs.
+  return LookupImportedObject(name);
 }
 
 
-RawObject* Library::LookupObject(const String& name,
-                                 String* ambiguity_error_msg) const {
+RawObject* Library::LookupObject(const String& name) const {
   // First check if name is found in the local scope of the library.
   Object& obj = Object::Handle(LookupLocalObject(name));
   if (!obj.IsNull()) {
     return obj.raw();
   }
-  // Now check if name is found in any imported libs. It is a compile-time error
-  // if the name is found in more than one import and actually used.
-  return LookupImportedObject(name, ambiguity_error_msg);
+  // Now check if name is found in any imported libs.
+  return LookupImportedObject(name);
 }
 
 
-RawObject* Library::LookupImportedObject(const String& name,
-                                         String* ambiguity_error_msg) const {
+RawObject* Library::LookupImportedObject(const String& name) const {
   Object& obj = Object::Handle();
   Namespace& import = Namespace::Handle();
   Library& import_lib = Library::Handle();
+  String& import_lib_url = String::Handle();
   String& first_import_lib_url = String::Handle();
   Object& found_obj = Object::Handle();
   for (intptr_t i = 0; i < num_imports(); i++) {
     import ^= ImportAt(i);
     obj = import.Lookup(name);
     if (!obj.IsNull()) {
       import_lib = import.library();
-      if (!first_import_lib_url.IsNull()) {
-        // Found duplicate definition.
-        const intptr_t kMessageBufferSize = 512;
-        char message_buffer[kMessageBufferSize];
-        if (first_import_lib_url.raw() == url()) {
-          OS::SNPrint(message_buffer,
-                      kMessageBufferSize,
-                      "ambiguous reference to '%s', "
-                      "as library '%s' is imported multiple times",
-                      name.ToCString(),
-                      first_import_lib_url.ToCString());
+      import_lib_url = import_lib.url();
+      if (found_obj.raw() != obj.raw()) {
+        if (first_import_lib_url.IsNull() ||
+            first_import_lib_url.StartsWith(Symbols::DartScheme())) {
+          // This is the first object we found, or the
+          // previously found object is exported from a Dart
+          // system library. The newly found object hides the one
+          // from the Dart library.
+          first_import_lib_url = import_lib.url();
+          found_obj = obj.raw();
+        } else if (import_lib_url.StartsWith(Symbols::DartScheme())) {
+          // The newly found object is exported from a Dart system
+          // library. It is hidden by the previously found object.
+          // We continue to search.
         } else {
-          OS::SNPrint(message_buffer,
-                      kMessageBufferSize,
-                      "ambiguous reference: "
-                      "'%s' is defined in library '%s' and also in '%s'",
-                      name.ToCString(),
-                      first_import_lib_url.ToCString(),
-                      String::Handle(url()).ToCString());
+          // We found two different objects with the same name.
+          return Object::null();
         }
-        // If the caller does not expect an ambiguity error, it may pass NULL as
-        // ambiguity_error_msg in order to avoid the allocation of a handle.
-        // It typically does so when looking up an object in the core library,
-        // which is guaranteed not to contain ambiguities, unless the core lib
-        // is under development, in which case the assert below may fail.
-        ASSERT(ambiguity_error_msg != NULL);  // No ambiguity error expected.
-        *ambiguity_error_msg = String::New(message_buffer);
-        return Object::null();
       }
-      first_import_lib_url = url();
-      found_obj = obj.raw();
     }
   }
   return found_obj.raw();
 }
 
 
-RawClass* Library::LookupClass(const String& name,
-                               String* ambiguity_error_msg) const {
-  Object& obj = Object::Handle(LookupObject(name, ambiguity_error_msg));
+RawClass* Library::LookupClass(const String& name) const {
+  Object& obj = Object::Handle(LookupObject(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 RawClass* Library::LookupLocalClass(const String& name) const {
   Object& obj = Object::Handle(LookupLocalObject(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
-RawClass* Library::LookupClassAllowPrivate(const String& name,
-                                           String* ambiguity_error_msg) const {
+RawClass* Library::LookupClassAllowPrivate(const String& name) const {
   // See if the class is available in this library or in the top level
   // scope of any imported library.
   Isolate* isolate = Isolate::Current();
-  const Class& cls = Class::Handle(isolate, LookupClass(name,
-                                                        ambiguity_error_msg));
+  const Class& cls = Class::Handle(isolate, LookupClass(name));
   if (!cls.IsNull()) {
     return cls.raw();
   }
 
   // Now try to lookup the class using its private name, but only in
   // this library (not in imported libraries).
   if (ShouldBePrivate(name)) {
     String& private_name = String::Handle(isolate, PrivateName(name));
     const Object& obj = Object::Handle(LookupLocalObject(private_name));
     if (obj.IsClass()) {
@@ skipping 461 matching lines @@
   if (num_current_imports >= length) {
     const intptr_t new_length = length + kIncrementSize;
     imports = Array::Grow(imports, new_length, Heap::kOld);
     set_imports(imports);
   }
   imports.SetAt(num_current_imports, import);
   set_num_imports(num_current_imports + 1);
 }
 
 
-RawClass* LibraryPrefix::LookupClass(const String& class_name,
-                                     String* ambiguity_error_msg) const {
+RawObject* LibraryPrefix::LookupObject(const String& name) const {
   Array& imports = Array::Handle(this->imports());
   Object& obj = Object::Handle();
   Namespace& import = Namespace::Handle();
   Library& import_lib = Library::Handle();
+  String& import_lib_url = String::Handle();
   String& first_import_lib_url = String::Handle();
   Object& found_obj = Object::Handle();
   for (intptr_t i = 0; i < num_imports(); i++) {
     import ^= imports.At(i);
-    obj = import.Lookup(class_name);
+    obj = import.Lookup(name);
     if (!obj.IsNull()) {
       import_lib = import.library();
-      if (!first_import_lib_url.IsNull()) {
-        // Found duplicate definition.
-        const intptr_t kMessageBufferSize = 512;
-        char message_buffer[kMessageBufferSize];
-        if (first_import_lib_url.raw() == import_lib.url()) {
-          OS::SNPrint(message_buffer,
-                      kMessageBufferSize,
-                      "ambiguous reference to '%s', "
-                      "as library '%s' is imported multiple times via "
-                      "prefix '%s'",
-                      class_name.ToCString(),
-                      first_import_lib_url.ToCString(),
-                      String::Handle(name()).ToCString());
+      import_lib_url = import_lib.url();
+      if (found_obj.raw() != obj.raw()) {
+        if (first_import_lib_url.IsNull() ||
+            first_import_lib_url.StartsWith(Symbols::DartScheme())) {
+          // This is the first object we found, or the
+          // previously found object is exported from a Dart
+          // system library. The newly found object hides the one
+          // from the Dart library.
+          first_import_lib_url = import_lib.url();
+          found_obj = obj.raw();
+        } else if (import_lib_url.StartsWith(Symbols::DartScheme())) {
+          // The newly found object is exported from a Dart system
+          // library. It is hidden by the previously found object.
+          // We continue to search.
         } else {
-          OS::SNPrint(message_buffer,
-                      kMessageBufferSize,
-                      "ambiguous reference: "
-                      "'%s' is defined in library '%s' and also in '%s', "
-                      "both imported via prefix '%s'",
-                      class_name.ToCString(),
-                      first_import_lib_url.ToCString(),
-                      String::Handle(import_lib.url()).ToCString(),
-                      String::Handle(name()).ToCString());
+          // We found two different objects with the same name.
+          return Object::null();
         }
-        // If the caller does not expect an ambiguity error, it may pass NULL as
-        // ambiguity_error_msg in order to avoid the allocation of a handle.
-        // It typically does so when looking up a class in the core library,
-        // which is guaranteed not to contain ambiguities, unless the core lib
-        // is under development, in which case the assert below may fail.
-        ASSERT(ambiguity_error_msg != NULL);  // No ambiguity error expected.
-        *ambiguity_error_msg = String::New(message_buffer);
-        return Class::null();
       }
-      first_import_lib_url = import_lib.url();
-      found_obj = obj.raw();
     }
   }
-  if (found_obj.IsClass()) {
-    return Class::Cast(found_obj).raw();
+  return found_obj.raw();
+}
+
+
+RawClass* LibraryPrefix::LookupClass(const String& class_name) const {
+  const Object& obj = Object::Handle(LookupObject(class_name));
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
   ASSERT(Object::library_prefix_class() != Class::null());
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
@@ skipping 98 matching lines @@
     }
     // There is a list of visible names. The name we're looking for is not
     // contained in the list, so it is hidden.
     return true;
   }
   // The name is not filtered out.
   return false;
 }
 
 
+// Look up object with given name in library and filter out hidden
+// names. Also look up getters and setters.
 RawObject* Namespace::Lookup(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
   intptr_t ignore = 0;
+
   // Lookup the name in the library's symbols.
+  const String* filter_name = &name;
   Object& obj = Object::Handle(isolate, lib.LookupEntry(name, &ignore));
+  if (Field::IsGetterName(name)) {
+    filter_name = &String::Handle(Field::NameFromGetter(name));
+  } else if (Field::IsSetterName(name)) {
+    filter_name = &String::Handle(Field::NameFromGetter(name));
+  } else {
+    if (obj.IsNull() || obj.IsLibraryPrefix()) {
+      obj = lib.LookupEntry(String::Handle(Field::GetterName(name)), &ignore);
+      if (obj.IsNull()) {
+        obj = lib.LookupEntry(String::Handle(Field::SetterName(name)), &ignore);
+      }
+    }
+  }
+
   // Library prefixes are not exported.
   if (obj.IsNull() || obj.IsLibraryPrefix()) {
     // Lookup in the re-exported symbols.
-    obj = lib.LookupExport(name);
+    obj = lib.LookupReExport(name);
   }
-  if (obj.IsNull() || HidesName(name) || obj.IsLibraryPrefix()) {
+  if (obj.IsNull() || HidesName(*filter_name) || obj.IsLibraryPrefix()) {
     return Object::null();
   }
   return obj.raw();
 }
 
 
 RawNamespace* Namespace::New() {
   ASSERT(Object::namespace_class() != Class::null());
   RawObject* raw = Object::Allocate(Namespace::kClassId,
                                     Namespace::InstanceSize(),
@@ skipping 53 matching lines @@
                                 const char* class_name,
                                 const char* function_name) {
   Function& func = Function::Handle();
   String& class_str = String::Handle();
   String& func_str = String::Handle();
   Class& cls = Class::Handle();
   for (intptr_t l = 0; l < libs.length(); l++) {
     const Library& lib = *libs[l];
     if (strcmp(class_name, "::") == 0) {
       func_str = Symbols::New(function_name);
-      func = lib.LookupFunctionAllowPrivate(func_str, NULL);
+      func = lib.LookupFunctionAllowPrivate(func_str);
     } else {
       class_str = String::New(class_name);
-      cls = lib.LookupClassAllowPrivate(class_str, NULL);
+      cls = lib.LookupClassAllowPrivate(class_str);
       if (!cls.IsNull()) {
         func_str = String::New(function_name);
         if (function_name[0] == '.') {
           func_str = String::Concat(class_str, func_str);
         }
         func = cls.LookupFunctionAllowPrivate(func_str);
       }
     }
     if (!func.IsNull()) {
       return func.raw();
@@ skipping 7119 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart