Update handling of ambiguous name references

runtime/vm/dart_entry.cc

 // Copyright (c) 2011, 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/dart_entry.h"
 
 #include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
@@ skipping 100 matching lines @@
 RawObject* DartEntry::InvokeNoSuchMethod(const Instance& receiver,
                                          const String& target_name,
                                          const Array& arguments,
                                          const Array& arguments_descriptor) {
   ASSERT(receiver.raw() == arguments.At(0));
   // Allocate an Invocation object.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
 
   Class& invocation_mirror_class = Class::Handle(
       core_lib.LookupClass(
-          String::Handle(core_lib.PrivateName(Symbols::InvocationMirror())),
-          NULL));  // No ambiguity error expected.
+          String::Handle(core_lib.PrivateName(Symbols::InvocationMirror()))));
   ASSERT(!invocation_mirror_class.IsNull());
   const String& function_name =
       String::Handle(core_lib.PrivateName(Symbols::AllocateInvocationMirror()));
   const Function& allocation_function = Function::Handle(
       Resolver::ResolveStaticByName(invocation_mirror_class,
                                     function_name,
                                     Resolver::kIsQualified));
   ASSERT(!allocation_function.IsNull());
   const int kNumAllocationArgs = 3;
   const Array& allocation_args = Array::Handle(Array::New(kNumAllocationArgs));
@@ skipping 162 matching lines @@
   for (int i = 0; i < kCachedDescriptorCount; i++) {
     cached_args_descriptors_[i] = ArgumentsDescriptor::NewNonCached(i, false);
   }
 }
 
 
 RawObject* DartLibraryCalls::InstanceCreate(const Library& lib,
                                             const String& class_name,
                                             const String& constructor_name,
                                             const Array& arguments) {
-  const Class& cls = Class::Handle(
-      lib.LookupClassAllowPrivate(class_name, NULL));  // No ambiguity expected.
+  const Class& cls = Class::Handle(lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
   // For now, we only support a non-parameterized or raw type.
   const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
   const Instance& exception_object = Instance::Handle(Instance::New(cls));
   const Array& constructor_arguments =
     Array::Handle(Array::New(arguments.Length() + kNumExtraArgs));
   constructor_arguments.SetAt(0, exception_object);
   constructor_arguments.SetAt(
       1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
   Object& obj = Object::Handle();
@@ skipping 68 matching lines @@
     ASSERT(!isolate_lib.IsNull());
     const String& class_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
     const String& function_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_lookupReceivePort()));
     function = Resolver::ResolveStatic(isolate_lib,
                                        class_name,
                                        function_name,
                                        kNumArguments,
                                        Object::empty_array(),
-                                       Resolver::kIsQualified,
-                                       NULL);  // No ambiguity error expected.
+                                       Resolver::kIsQualified);
     ASSERT(!function.IsNull());
     isolate->object_store()->set_lookup_receive_port_function(function);
   }
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(Integer::New(port_id)));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(function, args));
   return result.raw();
 }
 
@@ skipping 11 matching lines @@
     ASSERT(!isolate_lib.IsNull());
     const String& class_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
     const String& function_name =
         String::Handle(isolate_lib.PrivateName(Symbols::_handleMessage()));
     function = Resolver::ResolveStatic(isolate_lib,
                                        class_name,
                                        function_name,
                                        kNumArguments,
                                        Object::empty_array(),
-                                       Resolver::kIsQualified,
-                                       NULL);  // No ambiguity error expected.
+                                       Resolver::kIsQualified);
     ASSERT(!function.IsNull());
     isolate->object_store()->set_handle_message_function(function);
   }
   const Array& args = Array::Handle(isolate, Array::New(kNumArguments));
   args.SetAt(0, receive_port);
   args.SetAt(1, Integer::Handle(isolate, Integer::New(reply_port_id)));
   args.SetAt(2, message);
   if (isolate->debugger()->IsStepping()) {
     // If the isolate is being debugged and the debugger was stepping
     // through code, enable single stepping so debugger will stop
@@ skipping 14 matching lines @@
       String::Handle(isolate_lib.PrivateName(Symbols::_SendPortImpl()));
   const int kNumArguments = 1;
   const String& function_name =
       String::Handle(isolate_lib.PrivateName(Symbols::_create()));
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
                               Object::empty_array(),
-                              Resolver::kIsQualified,
-                              NULL));  // No ambiguity error expected.
+                              Resolver::kIsQualified));
   ASSERT(!function.IsNull());
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(Integer::New(port_id)));
   return DartEntry::InvokeFunction(function, args);
 }
 
 
 RawObject* DartLibraryCalls::MapSetAt(const Instance& map,
                                       const Instance& key,
                                       const Instance& value) {
@@ skipping 23 matching lines @@
           String::Handle(Field::GetterName(Symbols::_id()))));
   const Function& func = Function::Handle(cls.LookupDynamicFunction(func_name));
   ASSERT(!func.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, port);
   return DartEntry::InvokeFunction(func, args);
 }
 
 
 }  // namespace dart