Refactor resolution code in the vm to properly handle ambiguity errors.

runtime/lib/mirrors.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 "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"  // TODO(11742): Remove with CreateMirrorRef.
 #include "vm/bootstrap_natives.h"
@@ skipping 1654 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(
       String, function_name, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(
       Array, positional_args, arguments->NativeArgAt(3));
 
   intptr_t number_of_arguments = positional_args.Length();
 
 
+  String& ambiguity_error_msg = String::Handle(isolate);
   const Function& function = Function::Handle(
-      library.LookupFunctionAllowPrivate(function_name));
+      library.LookupFunctionAllowPrivate(function_name, &ambiguity_error_msg));
 
   if (function.IsNull()) {
-    const String& message = String::Handle(
-      String::NewFormatted("%s: did not find top-level function '%s'.",
-                           "LibraryMirror_invoke",
-                           function_name.ToCString()));
-    ThrowMirroredCompilationError(message);
+    if (ambiguity_error_msg.IsNull()) {
+      const String& message = String::Handle(
+        String::NewFormatted("%s: did not find top-level function '%s'.",
+                             "LibraryMirror_invoke",
+                             function_name.ToCString()));
+      ThrowMirroredCompilationError(message);
+    } else {
+      ThrowMirroredCompilationError(ambiguity_error_msg);
+    }
     UNREACHABLE();
   }
 
   // LookupFunctionAllowPrivate does not check argument arity, so we
   // do it here.
   String& error_message = String::Handle();
   if (!function.AreValidArgumentCounts(number_of_arguments,
                                        /* num_named_args */ 0,
                                        &error_message)) {
     const String& message = String::Handle(
@@ skipping 19 matching lines @@
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, getter_name, arguments->NativeArgAt(2));
 
   // To access a top-level we may need to use the Field or the
   // getter Function.  The getter function may either be in the
   // library or in the field's owner class, depending.
-  const Field& field =
-      Field::Handle(library.LookupFieldAllowPrivate(getter_name));
+  String& ambiguity_error_msg = String::Handle(isolate);
+  const Field& field = Field::Handle(
+      library.LookupFieldAllowPrivate(getter_name, &ambiguity_error_msg));
   Function& getter = Function::Handle();
-  if (field.IsNull()) {
-    // No field found.  Check for a getter in the lib.
+  if (field.IsNull() && ambiguity_error_msg.IsNull()) {
+    // No field found and no ambiguity error.  Check for a getter in the lib.
     const String& internal_getter_name =
         String::Handle(Field::GetterName(getter_name));
-    getter = library.LookupFunctionAllowPrivate(internal_getter_name);
-  } else if (FieldIsUninitialized(field)) {
+    getter = library.LookupFunctionAllowPrivate(internal_getter_name,
+                                                &ambiguity_error_msg);
+  } else if (!field.IsNull() && FieldIsUninitialized(field)) {
     // A field was found.  Check for a getter in the field's owner classs.
     const Class& klass = Class::Handle(field.owner());
     const String& internal_getter_name =
         String::Handle(Field::GetterName(getter_name));
     getter = klass.LookupStaticFunctionAllowPrivate(internal_getter_name);
   }
 
   if (!getter.IsNull()) {
     // Invoke the getter and return the result.
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
     if (result.IsError()) {
       ThrowInvokeError(Error::Cast(result));
       UNREACHABLE();
     }
     return result.raw();
-  } else if (!field.IsNull()) {
+  }
+  if (!field.IsNull()) {
     return field.value();
-  } else {
+  }
+  if (ambiguity_error_msg.IsNull()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: did not find top-level variable '%s'.",
                              "LibraryMirror_invokeGetter",
                              getter_name.ToCString()));
     ThrowMirroredCompilationError(message);
-    UNREACHABLE();
-    return Instance::null();
+  } else {
+    ThrowMirroredCompilationError(ambiguity_error_msg);
   }
+  UNREACHABLE();
+  return Instance::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invokeSetter, 4) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
   // with its cousins.
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
   GET_NON_NULL_NATIVE_ARGUMENT(String, setter_name, arguments->NativeArgAt(2));
   GET_NATIVE_ARGUMENT(Instance, value, arguments->NativeArgAt(3));
 
   // To access a top-level we may need to use the Field or the
   // setter Function.  The setter function may either be in the
   // library or in the field's owner class, depending.
-  const Field& field =
-      Field::Handle(library.LookupFieldAllowPrivate(setter_name));
+  String& ambiguity_error_msg = String::Handle(isolate);
+  const Field& field = Field::Handle(
+      library.LookupFieldAllowPrivate(setter_name, &ambiguity_error_msg));
 
-  if (field.IsNull()) {
+  if (field.IsNull() && ambiguity_error_msg.IsNull()) {
     const String& internal_setter_name =
         String::Handle(Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
-        library.LookupFunctionAllowPrivate(internal_setter_name));
-
+        library.LookupFunctionAllowPrivate(internal_setter_name,
+                                           &ambiguity_error_msg));
     if (setter.IsNull()) {
-      const String& message = String::Handle(
-        String::NewFormatted("%s: did not find top-level variable '%s'.",
-                             "LibraryMirror_invokeSetter",
-                             setter_name.ToCString()));
-      ThrowMirroredCompilationError(message);
+      if (ambiguity_error_msg.IsNull()) {
+        const String& message = String::Handle(
+          String::NewFormatted("%s: did not find top-level variable '%s'.",
+                               "LibraryMirror_invokeSetter",
+                               setter_name.ToCString()));
+        ThrowMirroredCompilationError(message);
+      } else {
+        ThrowMirroredCompilationError(ambiguity_error_msg);
+      }
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
     args.SetAt(0, value);
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(setter, args));
     if (result.IsError()) {
@@ skipping 51 matching lines @@
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
 
   const AbstractType& type = AbstractType::Handle(field.type());
   return CreateTypeMirror(type);
 }
 
 }  // namespace dart