Fix wrong detection of duplicate definition of function types (issue 187).

runtime/vm/object.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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 995 matching lines @@
 
 RawClass* Class::NewInterface(const String& name, const Script& script) {
   Class& result = Class::Handle(New<Instance>(name, script));
   result.set_is_interface();
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
-                                   const Script& script,
-                                   intptr_t token_index) {
+                                   const Script& script) {
   ASSERT(!signature_function.IsNull());
   Type& super_type = Type::Handle(Type::ObjectType());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
   TypeArray& type_parameter_extends = TypeArray::Handle();
   if (!signature_function.is_static()) {
     if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
       // Share the function owner super class as the super class of the
@@ skipping 11 matching lines @@
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.set_type_parameter_extends(type_parameter_extends);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
   // Implements interface Function.
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_interface);
   result.set_interfaces(interfaces);
+  // Unless the signature function already has a signature class, create a
+  // canonical signature class by having the signature function pointing back to
+  // the signature class.
+  if (signature_function.signature_class() == Object::null()) {
+    signature_function.set_signature_class(result);
+  }
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   switch (kind) {
     case kUnhandledException:
       ASSERT(object_store->unhandled_exception_class() != Class::null());
       return object_store->unhandled_exception_class();
@@ skipping 133 matching lines @@
   ASSERT(raw_ptr()->allocation_stub_ == Code::null());
   StorePointer(&raw_ptr()->allocation_stub_, value.raw());
 }
 
 
 bool Class::IsObjectClass() const {
   return raw() == Type::Handle(Type::ObjectType()).type_class();
 }
 
 
+bool Class::IsCanonicalSignatureClass() const {
+  const Function& function = Function::Handle(signature_function());
+  return (!function.IsNull() && (function.signature_class() == raw()));
+}
+
+
 // TODO(regis): We can probably merge this function with IsSubtypeOf, but since
 // the spec is not definitive, we still follow it somewhat closely, to make it
 // easier to implement spec changes.
 bool Class::IsMoreSpecificThan(
     const TypeArguments& type_arguments,
     const Class& other,
     const TypeArguments& other_type_arguments) const {
   // Check for VarType.
   // The VarType on the lefthand side is replaced by the bottom type, which is
   // more specific than any type.
@@ skipping 1725 matching lines @@
                                                                 Heap::kOld)));
   Type& param_type = Type::Handle();
   String& param_name = String::Handle();
   for (int i = 0; i < num_params; i++) {
     param_type = ParameterTypeAt(i + has_receiver);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(i + has_receiver);
     closure_function.SetParameterNameAt(i, param_name);
   }
 
-  // Lookup or create a new function type for the closure function in the
+  // Lookup or create a new signature class for the closure function in the
   // library of the owner class.
   const Class& owner_class = Class::Handle(owner());
   ASSERT(!owner_class.IsNull() && (owner() == closure_function.owner()));
   const Library& library = Library::Handle(owner_class.library());
   ASSERT(!library.IsNull());
   const String& signature = String::Handle(closure_function.Signature());
-  Class& signature_class = Class::ZoneHandle(library.LookupClass(signature));
+  Class& signature_class = Class::ZoneHandle(
+      library.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     const Script& script = Script::Handle(owner_class.script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
-                                               script,
-                                               token_index());
+                                               script);
     library.AddClass(signature_class);
+  } else {
+    closure_function.set_signature_class(signature_class);
   }
-  ASSERT(!Function::Handle(signature_class.signature_function()).IsNull());
-  ASSERT(Class::Handle(closure_function.signature_class()).IsNull());
-  closure_function.set_signature_class(signature_class);
+  ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
@@ skipping 564 matching lines @@
   StorePointer(&raw_ptr()->dictionary_, new_dict.raw());
 }
 
 
 void Library::AddObject(const Object& obj, const String& name) const {
   ASSERT(obj.IsClass() ||
          obj.IsFunction() ||
          obj.IsField() ||
          obj.IsLibraryPrefix());
   ASSERT((LookupObject(name) == Object::null()) ||
-         (obj.IsLibraryPrefix() &&
+         ((obj.IsLibraryPrefix() ||
+           (obj.IsClass() &&
+            Class::CheckedHandle(obj.raw()).IsCanonicalSignatureClass())) &&
           (LookupLocalObject(name) == Object::null())));
   const Array& dict = Array::Handle(dictionary());
   intptr_t dict_size = dict.Length() - 1;
   intptr_t index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle();
   entry = dict.At(index);
   // An empty spot will be found because we keep the hash set at most 75% full.
   while (!entry.IsNull()) {
     index = (index + 1) % dict_size;
@@ skipping 154 matching lines @@
   Object& obj = Object::Handle();
   Class& cls = Class::Handle();
   Function& func = Function::Handle();
   Field& field = Field::Handle();
   String& entry_name = String::Handle();
   while (it.HasNext()) {
     obj = it.GetNext();
     ASSERT(!obj.IsNull());
     if (obj.IsClass()) {
       cls ^= obj.raw();
-      if (cls.IsSignatureClass()) {
+      if (cls.IsCanonicalSignatureClass()) {
         continue;
       }
       entry_name = cls.Name();
     } else if (obj.IsFunction()) {
       func ^= obj.raw();
       entry_name = func.name();
     } else if (obj.IsField()) {
       field ^= obj.raw();
       entry_name = field.name();
     } else {
@@ skipping 3057 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart