Update handling of ambiguous name references

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 235 matching lines @@
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
 }
 
 
 // Resolve unresolved_class in the library of cls, or return null.
-RawClass* ClassFinalizer::ResolveClass(const Class& cls,
-                                       const UnresolvedClass& unresolved_class,
-                                       Error* ambiguity_error) {
+RawClass* ClassFinalizer::ResolveClass(
+      const Class& cls,
+      const UnresolvedClass& unresolved_class) {
   const String& class_name = String::Handle(unresolved_class.ident());
   Library& lib = Library::Handle();
   Class& resolved_class = Class::Handle();
-  String& ambiguity_error_msg = String::Handle();
   if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
     lib = cls.library();
     ASSERT(!lib.IsNull());
-    resolved_class = lib.LookupClass(class_name, &ambiguity_error_msg);
+    resolved_class = lib.LookupClass(class_name);
   } else {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
-    resolved_class = lib_prefix.LookupClass(class_name, &ambiguity_error_msg);
-  }
-  if (resolved_class.IsNull() && !ambiguity_error_msg.IsNull()) {
-    const Script& script = Script::Handle(cls.script());
-    *ambiguity_error = Parser::FormatErrorMsg(
-        script, unresolved_class.token_pos(), "Error",
-        "%s", ambiguity_error_msg.ToCString());
+    resolved_class = lib_prefix.LookupClass(class_name);
   }
   return resolved_class.raw();
 }
 
 
 
 void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
                                                const Function& factory) {
   const Function& target = Function::Handle(factory.RedirectionTarget());
   if (target.IsNull()) {
@@ skipping 172 matching lines @@
   if (!type.HasResolvedTypeClass()) {
     // Type parameters are always resolved in the parser in the correct
     // non-static scope or factory scope. That resolution scope is unknown here.
     // Being able to resolve a type parameter from class cls here would indicate
     // that the type parameter appeared in a static scope. Leaving the type as
     // unresolved is the correct thing to do.
 
     // Lookup the type class.
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
-    Error& ambiguous_error = Error::Handle();
     const Class& type_class =
-        Class::Handle(ResolveClass(cls, unresolved_class, &ambiguous_error));
+        Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     const Type& parameterized_type = Type::Cast(type);
     if (type_class.IsNull()) {
       if ((finalization == kCanonicalizeWellFormed) ||
           FLAG_error_on_bad_type) {
         // The type class could not be resolved. The type is malformed.
         FinalizeMalformedType(
-            ambiguous_error,  // May be null.
+            Error::Handle(),  // No previous error.
             cls,
             parameterized_type,
             "cannot resolve class '%s' from '%s'",
             String::Handle(unresolved_class.Name()).ToCString(),
             String::Handle(cls.Name()).ToCString());
       } else {
         // Map the malformed type to dynamic and ignore type arguments.
         parameterized_type.set_type_class(Class::Handle(
             Object::dynamic_class()));
         parameterized_type.set_arguments(
@@ skipping 1835 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart