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

runtime/vm/parser_test.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/ast_printer.h"
 #include "vm/class_finalizer.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 
 void DumpFunction(const Library& lib, const char* cname, const char* fname) {
   const String& classname = String::Handle(Symbols::New(cname));
-  Class& cls = Class::Handle(lib.LookupClass(classname));
-  EXPECT(!cls.IsNull());
+  String& ambiguity_error_msg = String::Handle();
+  Class& cls = Class::Handle(lib.LookupClass(classname, &ambiguity_error_msg));
+  EXPECT(!cls.IsNull());  // No ambiguity error expected.
 
   String& funcname = String::Handle(String::New(fname));
   Function& function = Function::ZoneHandle(cls.LookupStaticFunction(funcname));
   EXPECT(!function.IsNull());
 
   bool retval;
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
@@ skipping 12 matching lines @@
   isolate->set_long_jump_base(base);
 }
 
 
 void CheckField(const Library& lib,
                 const char* class_name,
                 const char* field_name,
                 bool expect_static,
                 bool is_final) {
   const String& classname = String::Handle(Symbols::New(class_name));
-  Class& cls = Class::Handle(lib.LookupClass(classname));
-  EXPECT(!cls.IsNull());
+  String& ambiguity_error_msg = String::Handle();
+  Class& cls = Class::Handle(lib.LookupClass(classname, &ambiguity_error_msg));
+  EXPECT(!cls.IsNull());  // No ambiguity error expected.
 
   String& fieldname = String::Handle(String::New(field_name));
   String& functionname = String::Handle();
   Function& function = Function::Handle();
   Field& field = Field::Handle();
   if (expect_static) {
     field ^= cls.LookupStaticField(fieldname);
     functionname ^= Field::GetterName(fieldname);
     function ^= cls.LookupStaticFunction(functionname);
     EXPECT(function.IsNull());
@@ skipping 13 matching lines @@
 
   EXPECT_EQ(field.is_static(), expect_static);
 }
 
 
 void CheckFunction(const Library& lib,
                    const char* class_name,
                    const char* function_name,
                    bool expect_static) {
   const String& classname = String::Handle(Symbols::New(class_name));
-  Class& cls = Class::Handle(lib.LookupClass(classname));
-  EXPECT(!cls.IsNull());
+  String& ambiguity_error_msg = String::Handle();
+  Class& cls = Class::Handle(lib.LookupClass(classname, &ambiguity_error_msg));
+  EXPECT(!cls.IsNull());  // No ambiguity error expected.
 
   String& functionname = String::Handle(String::New(function_name));
   Function& function = Function::Handle();
   if (expect_static) {
     function ^= cls.LookupStaticFunction(functionname);
   } else {
     function ^= cls.LookupDynamicFunction(functionname);
   }
   EXPECT(!function.IsNull());
 }
@@ skipping 60 matching lines @@
   Parser::ParseCompilationUnit(lib, script);
   EXPECT(ClassFinalizer::FinalizePendingClasses());
 
   DumpFunction(lib, "A", "foo");
   DumpFunction(lib, "A", "bar");
   DumpFunction(lib, "A", "baz");
   DumpFunction(lib, "B", "bam");
 }
 
 }  // namespace dart