Revert "Fix resolution and canonicalization of typedefs and function types..."

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() || IsSignatureFunction());
+  ASSERT(!value.IsNull());
   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 1205 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 {
   // NOTE(turnidge): If you update this function, you probably want to
   // update Class::PatchFieldsAndFunctions() at the same time.
   if (token_pos() == TokenPosition::kMinSource) {
     // Testing for position 0 is an optimization that relies on temporary
     // eval functions having token position 0.
     const Script& script = Script::Handle(eval_script());
     if (!script.IsNull()) {
       return script.raw();
     }
   }
   if (IsClosureFunction()) {
     return Function::Handle(parent_function()).script();
   }
   const Object& obj = Object::Handle(raw_ptr()->owner_);
-  if (obj.IsNull()) {
-    ASSERT(IsSignatureFunction());
-    return Script::null();
-  }
   if (obj.IsClass()) {
     return Class::Cast(obj).script();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).script();
 }
 
 
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(CurrentCode()).is_optimized();
@@ skipping 297 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