Avoid an assert fault in snapshot writer by making sure that the parent of a

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 5713 matching lines @@
   ASSERT(!obj.IsNull());
   if (IsSignatureFunction()) {
     return SignatureData::Cast(obj).signature_type();
   } else {
     ASSERT(IsClosureFunction());
     return ClosureData::Cast(obj).signature_type();
   }
 }
 
 
+RawFunction* Function::CanonicalSignatureFunction(TrailPtr trail) const {
+  ASSERT(!IsSignatureFunction());
+  Zone* zone = Thread::Current()->zone();
+  Function& parent = Function::Handle(zone, parent_function());
+  if (!parent.IsNull() && !parent.IsSignatureFunction()) {
+    // Make sure the parent function is also a signature function.
+    parent = parent.CanonicalSignatureFunction(trail);
+  }
+  const Class& owner = Class::Handle(zone, Owner());
+  const Function& sig_fun = Function::Handle(
+      zone,
+      Function::NewSignatureFunction(owner, parent, TokenPosition::kNoSource));
+  // In case of a generic function, the function type parameters in the
+  // signature will still refer to the original function. This should not
+  // be a problem, since once finalized the indices will be identical.
+  sig_fun.set_type_parameters(TypeArguments::Handle(zone, type_parameters()));
+  ASSERT(HasGenericParent() == sig_fun.HasGenericParent());
+  ASSERT(IsGeneric() == sig_fun.IsGeneric());
+  AbstractType& type = AbstractType::Handle(zone);
+  type = result_type();
+  type = type.Canonicalize(trail);
+  sig_fun.set_result_type(type);
+  const intptr_t num_params = NumParameters();
+  sig_fun.set_num_fixed_parameters(num_fixed_parameters());
+  sig_fun.SetNumOptionalParameters(NumOptionalParameters(),
+                                   HasOptionalPositionalParameters());
+  sig_fun.set_parameter_types(
+      Array::Handle(Array::New(num_params, Heap::kOld)));
+  for (intptr_t i = 0; i < num_params; i++) {
+    type = ParameterTypeAt(i);
+    type = type.Canonicalize(trail);
+    sig_fun.SetParameterTypeAt(i, type);
+  }
+  sig_fun.set_parameter_names(Array::Handle(zone, parameter_names()));
+  return sig_fun.raw();
+}
+
+
 RawType* Function::SignatureType() const {
   Type& type = Type::Handle(ExistingSignatureType());
   if (type.IsNull()) {
     // The function type of this function is not yet cached and needs to be
     // constructed and cached here.
     // A function type is type parameterized in the same way as the owner class
     // of its non-static signature function.
     // It is not type parameterized if its signature function is static, or if
     // none of its result type or formal parameter types are type parameterized.
     // Unless the function type is a generic typedef, the type arguments of the
@@ skipping 11965 matching lines @@
       // Cycles via typedefs are detected and disallowed, but a function type
       // can be recursive due to a cycle in its type arguments.
       return this->raw();
     }
     set_arguments(type_args);
     ASSERT(type_args.IsNull() || type_args.IsOld());
 
     // In case of a function type, replace the actual function by a signature
     // function.
     if (IsFunctionType()) {
-      const Function& fun = Function::Handle(zone, signature());
-      if (!fun.IsSignatureFunction()) {
-        // In case of a generic function, the function type parameters in the
-        // signature will still refer to the original function. This should not
-        // be a problem, since they are finalized and the indices remain
-        // unchanged.
-        const Function& parent = Function::Handle(zone, fun.parent_function());
-        Function& sig_fun =
-            Function::Handle(zone, Function::NewSignatureFunction(
-                                       cls, parent, TokenPosition::kNoSource));
-        sig_fun.set_type_parameters(
-            TypeArguments::Handle(zone, fun.type_parameters()));
-        ASSERT(fun.HasGenericParent() == sig_fun.HasGenericParent());
-        ASSERT(fun.IsGeneric() == sig_fun.IsGeneric());
-        type = fun.result_type();
-        type = type.Canonicalize(trail);
-        sig_fun.set_result_type(type);
-        const intptr_t num_params = fun.NumParameters();
-        sig_fun.set_num_fixed_parameters(fun.num_fixed_parameters());
-        sig_fun.SetNumOptionalParameters(fun.NumOptionalParameters(),
-                                         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()));
+      Function& sig_fun = Function::Handle(zone, signature());
+      if (!sig_fun.IsSignatureFunction()) {
+        sig_fun = sig_fun.CanonicalSignatureFunction(trail);
         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.
@@ skipping 5800 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart