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

runtime/vm/object_test.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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/simulator.h"
 #include "vm/symbols.h"
@@ skipping 117 matching lines @@
     TypeArguments::New(2));
   type_arguments1.SetTypeAt(0, type1);
   type_arguments1.SetTypeAt(1, type2);
   const TypeArguments& type_arguments2 = TypeArguments::Handle(
     TypeArguments::New(2));
   type_arguments2.SetTypeAt(0, type1);
   type_arguments2.SetTypeAt(1, type2);
   EXPECT_NE(type_arguments1.raw(), type_arguments2.raw());
   OS::Print("1: %s\n", type_arguments1.ToCString());
   OS::Print("2: %s\n", type_arguments2.ToCString());
-  ASSERT(type_arguments1.Equals(type_arguments2));
+  EXPECT(type_arguments1.Equals(type_arguments2));
   TypeArguments& type_arguments3 = TypeArguments::Handle();
   type_arguments1.Canonicalize();
   type_arguments3 ^= type_arguments2.Canonicalize();
   EXPECT_EQ(type_arguments1.raw(), type_arguments3.raw());
 }
 
 
 TEST_CASE(TokenStream) {
   String& source = String::Handle(String::New("= ( 9 , ."));
   String& private_key = String::Handle(String::New(""));
@@ skipping 1513 matching lines @@
 
   other_array = Array::New(kArrayLen - 1);
   other_array.SetAt(0, array);
   other_array.SetAt(2, array);
   EXPECT(!array.Equals(other_array));
 
   EXPECT_EQ(0, Object::empty_array().Length());
 
   array.MakeImmutable();
   Object& obj = Object::Handle(array.raw());
-  ASSERT(obj.IsArray());
+  EXPECT(obj.IsArray());
 }
 
 
 TEST_CASE(StringCodePointIterator) {
   const String& str0 = String::Handle(String::New(""));
   String::CodePointIterator it0(str0);
   EXPECT(!it0.Next());
 
   const String& str1 = String::Handle(String::New(" \xc3\xa7 "));
   String::CodePointIterator it1(str1);
@@ skipping 323 matching lines @@
       /* 4 */ "    return 'foo';\n"
       /* 5 */ "  }\n"
       /* 6 */ "</script>\n";
   const char* line1 = text;
   const char* line2 = strstr(line1, "\n") + 1;
   const char* line3 = strstr(line2, "\n") + 1;
   const char* line4 = strstr(line3, "\n") + 1;
   const char* line5 = strstr(line4, "\n") + 1;
 
   const int first_dart_line = 3;
-  ASSERT(strstr(line3, "main") != NULL);
+  EXPECT(strstr(line3, "main") != NULL);
   const int last_dart_line = 5;
-  ASSERT(strstr(line5, "}") != NULL);
+  EXPECT(strstr(line5, "}") != NULL);
 
   const char* script_begin = strstr(text, "main");
-  ASSERT(script_begin != NULL);
+  EXPECT(script_begin != NULL);
   const char* script_end = strstr(text, "</script>");
-  ASSERT(script_end != NULL);
+  EXPECT(script_end != NULL);
   int script_length = script_end - script_begin;
-  ASSERT(script_length > 0);
+  EXPECT(script_length > 0);
 
   // The Dart script starts on line 3 instead of 1, offset is 3 - 1 = 2.
   int line_offset = 2;
   // Dart script starts with "main" on line 3.
   intptr_t col_offset = script_begin - line3;
-  ASSERT(col_offset > 0);
+  EXPECT(col_offset > 0);
 
   char* src_chars = strdup(script_begin);
   src_chars[script_length] = '\0';
 
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(src_chars));
   const Script& script = Script::Handle(
       Script::New(url, source, RawScript::kScriptTag));
   script.SetLocationOffset(line_offset, col_offset);
 
@@ skipping 411 matching lines @@
   Library& lib = Library::Handle(Library::New(url));
   lib.AddClass(ae66);
   lib.AddObject(ce68, String::ZoneHandle(ce68.name()));
   lib.AddClass(re44);
   lib.AddObject(tee, String::ZoneHandle(tee.name()));
   ClassDictionaryIterator iterator(lib);
   int count = 0;
   Class& cls = Class::Handle();
   while (iterator.HasNext()) {
     cls = iterator.GetNextClass();
-    ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
+    EXPECT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
-  ASSERT(count == 2);
+  EXPECT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
   const String& function_name = String::Handle(Symbols::New(name));
   const Class& cls = Class::Handle(
        CreateDummyClass(function_name, Script::Handle()));
   const bool is_static = false;
   const bool is_const = false;
   const bool is_abstract = false;
@@ skipping 71 matching lines @@
   EXPECT_EQ(target1.raw(), scall_icdata.GetTargetAt(0));
 }
 
 
 TEST_CASE(SubtypeTestCache) {
   String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(CreateDummyClass(class_name, script));
   SubtypeTestCache& cache = SubtypeTestCache::Handle(SubtypeTestCache::New());
-  ASSERT(!cache.IsNull());
+  EXPECT(!cache.IsNull());
   EXPECT_EQ(0, cache.NumberOfChecks());
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(empty_class.id(), targ_0, targ_1, Bool::True());
   EXPECT_EQ(1, cache.NumberOfChecks());
   intptr_t test_class_id = -1;
   AbstractTypeArguments& test_targ_0 = AbstractTypeArguments::Handle();
   AbstractTypeArguments& test_targ_1 = AbstractTypeArguments::Handle();
   Bool& test_result = Bool::Handle();
   cache.GetCheck(0, &test_class_id, &test_targ_0, &test_targ_1, &test_result);
@@ skipping 620 matching lines @@
   EXPECT_EQ(returned_referent.raw(), library.raw());
 
   const MirrorReference& other_reference =
       MirrorReference::Handle(MirrorReference::New());
   EXPECT_NE(reference.raw(), other_reference.raw());
   other_reference.set_referent(library);
   EXPECT_NE(reference.raw(), other_reference.raw());
   EXPECT_EQ(reference.referent(), other_reference.referent());
 
   Object& obj = Object::Handle(reference.raw());
-  ASSERT(obj.IsMirrorReference());
+  EXPECT(obj.IsMirrorReference());
 }
 
 
 static RawFunction* GetFunction(const Class& cls, const char* name) {
   const Function& result = Function::Handle(cls.LookupDynamicFunction(
       String::Handle(String::New(name))));
-  ASSERT(!result.IsNull());
+  EXPECT(!result.IsNull());
   return result.raw();
 }
 
 
 static RawField* GetField(const Class& cls, const char* name) {
   const Field& field =
       Field::Handle(cls.LookupField(String::Handle(String::New(name))));
-  ASSERT(!field.IsNull());
+  EXPECT(!field.IsNull());
   return field.raw();
 }
 
 
 static RawClass* GetClass(const Library& lib, const char* name) {
-  const Class& cls =
-      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(name))));
-  ASSERT(!cls.IsNull());
+  String& ambiguity_error_msg = String::Handle();
+  const Class& cls = Class::Handle(
+      lib.LookupClass(String::Handle(Symbols::New(name)),
+                      &ambiguity_error_msg));
+  EXPECT(!cls.IsNull());  // No ambiguity error expected.
   return cls.raw();
 }
 
 
 static void PrintMetadata(const char* name, const Object& data) {
   if (data.IsError()) {
     OS::Print("Error in metadata evaluation for %s: '%s'\n",
               name,
               Error::Cast(data).ToErrorCString());
   }
-  ASSERT(data.IsArray());
+  EXPECT(data.IsArray());
   const Array& metadata = Array::Cast(data);
   OS::Print("Metadata for %s has %"Pd" values:\n", name, metadata.Length());
   Object& elem = Object::Handle();
   for (int i = 0; i < metadata.Length(); i++) {
     elem = metadata.At(i);
     OS::Print("  %d: %s\n", i, elem.ToCString());
   }
 }
 
 
@@ skipping 29 matching lines @@
       "A main() {                     \n"
       "  return new A();              \n"
       "}                              \n";
 
   Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(h_lib);
   Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(h_lib);
-  ASSERT(!lib.IsNull());
+  EXPECT(!lib.IsNull());
   const Class& class_a = Class::Handle(GetClass(lib, "A"));
   Object& res = Object::Handle(lib.GetMetadata(class_a));
   PrintMetadata("A", res);
 
   const Class& class_meta = Class::Handle(GetClass(lib, "Meta"));
   res = lib.GetMetadata(class_meta);
   PrintMetadata("Meta", res);
 
   Field& field = Field::Handle(GetField(class_a, "aField"));
   res = lib.GetMetadata(field);
   PrintMetadata("A.aField", res);
 
   Function& func = Function::Handle(GetFunction(class_a, "aFunc"));
   res = lib.GetMetadata(func);
   PrintMetadata("A.aFunc", res);
 
   func = lib.LookupLocalFunction(String::Handle(Symbols::New("main")));
-  ASSERT(!func.IsNull());
+  EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("main", res);
 
   func = lib.LookupLocalFunction(String::Handle(Symbols::New("get:tlGetter")));
-  ASSERT(!func.IsNull());
+  EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("tlGetter", res);
 
   field = lib.LookupLocalField(String::Handle(Symbols::New("gVar")));
-  ASSERT(!field.IsNull());
+  EXPECT(!field.IsNull());
   res = lib.GetMetadata(field);
   PrintMetadata("gVar", res);
 }
 
 
 TEST_CASE(FunctionSourceFingerprint) {
   const char* kScriptChars =
       "class A {\n"
       "  void test1(int a) {\n"
       "    return a > 1 ? a + 1 : a;\n"
@@ skipping 18 matching lines @@
       "        b - 2 : b;\n"
       "  }\n"
       "}";
   TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(ClassFinalizer::FinalizePendingClasses());
   const String& name = String::Handle(String::New(TestCase::url()));
   const Library& lib = Library::Handle(Library::LookupLibrary(name));
   EXPECT(!lib.IsNull());
 
   const Class& class_a = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New("A"))));
+      lib.LookupClass(String::Handle(Symbols::New("A")), NULL));
   const Function& test1 = Function::Handle(GetFunction(class_a, "test1"));
   const Function& test2 = Function::Handle(GetFunction(class_a, "test2"));
   const Function& test3 = Function::Handle(GetFunction(class_a, "test3"));
   const Function& test4 = Function::Handle(GetFunction(class_a, "test4"));
   const Function& test5 = Function::Handle(GetFunction(class_a, "test5"));
   const Function& test6 = Function::Handle(GetFunction(class_a, "test6"));
   const Function& test7 = Function::Handle(GetFunction(class_a, "test7"));
   EXPECT_EQ(test1.SourceFingerprint(), test2.SourceFingerprint());
   EXPECT_NE(test1.SourceFingerprint(), test3.SourceFingerprint());
   EXPECT_NE(test3.SourceFingerprint(), test4.SourceFingerprint());
   EXPECT_NE(test4.SourceFingerprint(), test5.SourceFingerprint());
   EXPECT_NE(test5.SourceFingerprint(), test6.SourceFingerprint());
   EXPECT_EQ(test6.SourceFingerprint(), test7.SourceFingerprint());
 }
 
 }  // namespace dart