Fix resolution and canonicalization of typedefs and function types in

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 5545 matching lines @@
   }
   return type.raw();
 }
 
 
 void Function::SetSignatureType(const Type& value) const {
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   if (IsSignatureFunction()) {
     SignatureData::Cast(obj).set_signature_type(value);
+    ASSERT(!value.IsCanonical() || (value.signature() == this->raw()));
   } else {
     ASSERT(IsClosureFunction());
     ClosureData::Cast(obj).set_signature_type(value);
   }
 }
 
 
 bool Function::IsRedirectingFactory() const {
   if (!IsFactory() || !is_redirecting()) {
     return false;
@@ skipping 139 matching lines @@
 }
 
 
 void Function::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void Function::set_owner(const Object& value) const {
-  ASSERT(!value.IsNull());
+  ASSERT(!value.IsNull() || IsSignatureFunction());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
 
 RawRegExp* Function::regexp() const {
   ASSERT(kind() == RawFunction::kIrregexpFunction);
   const Array& pair = Array::Cast(Object::Handle(raw_ptr()->data_));
   return RegExp::RawCast(pair.At(0));
 }
 
@@ skipping 1183 matching lines @@
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated()) {
       return false;
     }
   }
   return true;
 }
 
 
 RawClass* Function::Owner() const {
+  if (raw_ptr()->owner_ == Object::null()) {
+    ASSERT(IsSignatureFunction());
+    return Class::null();
+  }
   if (raw_ptr()->owner_->IsClass()) {
     return Class::RawCast(raw_ptr()->owner_);
   }
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).patched_class();
 }
 
 
 RawClass* Function::origin() const {
+  if (raw_ptr()->owner_ == Object::null()) {
+    ASSERT(IsSignatureFunction());
+    return Class::null();
+  }
   if (raw_ptr()->owner_->IsClass()) {
     return Class::RawCast(raw_ptr()->owner_);
   }
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).origin_class();
 }
 
 
 RawScript* Function::script() const {
@@ skipping 316 matching lines @@
 }
 
 
 void SignatureData::set_parent_function(const Function& value) const {
   StorePointer(&raw_ptr()->parent_function_, value.raw());
 }
 
 
 void SignatureData::set_signature_type(const Type& value) const {
   StorePointer(&raw_ptr()->signature_type_, value.raw());
-  // If the signature type is resolved, the parent function is not needed
-  // anymore (type parameters may be declared by generic parent functions).
-  // Keeping the parent function can unnecessarily pull more objects into a
-  // snapshot. Also, the parent function is meaningless once the signature type
-  // is canonicalized.
-
-// TODO(rmacnak): Keeping the parent function for unresolved signature types
-// is causing a tree shaking issue in AOT. Please, investigate.
-#if 0
-  if (value.IsResolved()) {
-    set_parent_function(Function::Handle());
-  }
-#else
-  set_parent_function(Function::Handle());
-#endif
 }
 
 
 RawSignatureData* SignatureData::New() {
   ASSERT(Object::signature_data_class() != Class::null());
   RawObject* raw = Object::Allocate(SignatureData::kClassId,
                                     SignatureData::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawSignatureData*>(raw);
 }
 
@@ skipping 9795 matching lines @@
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     clone.set_error(bound_error);
   }
   // Clone the signature if this type represents a function type.
   Function& fun = Function::Handle(zone, signature());
   if (!fun.IsNull()) {
     const Class& owner = Class::Handle(zone, fun.Owner());
     Function& fun_clone = Function::Handle(
         zone, Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
+    // TODO(regis): Handle cloning of a generic function type.
     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUnfinalized();
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
     fun_clone.set_parameter_types(
         Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
       type = fun.ParameterTypeAt(i);
       type = type.CloneUnfinalized();
       fun_clone.SetParameterTypeAt(i, type);
     }
     fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
     clone.set_signature(fun_clone);
+    fun_clone.SetSignatureType(clone);
   }
   clone.SetIsResolved();
   return clone.raw();
 }
 
 
 RawAbstractType* Type::CloneUninstantiated(const Class& new_owner,
                                            TrailPtr trail) const {
   ASSERT(IsFinalized());
   ASSERT(IsCanonical());
@@ skipping 176 matching lines @@
                                          fun.HasOptionalPositionalParameters());
         sig_fun.set_parameter_types(
             Array::Handle(Array::New(num_params, Heap::kOld)));
         for (intptr_t i = 0; i < num_params; i++) {
           type = fun.ParameterTypeAt(i);
           type = type.Canonicalize(trail);
           sig_fun.SetParameterTypeAt(i, type);
         }
         sig_fun.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
         set_signature(sig_fun);
+        // Note that the signature type of the signature function may be
+        // different than the type being canonicalized.
+        // Consider F<int> being canonicalized, with F being a typedef and F<T>
+        // being its signature type.
       }
     }
 
     // Check to see if the type got added to canonical list as part of the
     // type arguments canonicalization.
     SafepointMutexLocker ml(isolate->type_canonicalization_mutex());
     CanonicalTypeSet table(zone, object_store->canonical_types());
     type ^= table.GetOrNull(CanonicalTypeKey(*this));
     if (type.IsNull()) {
       // Add this Type into the canonical list of types.
@@ skipping 5557 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart