Make finalization of recursive function types more robust, especially since

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 16857 matching lines @@
   intptr_t len = num_type_args;  // Check the full vector of type args.
   ASSERT(num_type_args > 0);
   // This type is not instantiated if it refers to type parameters.
   // Although this type may still be unresolved, the type parameters it may
   // refer to are resolved by definition. We can therefore return the correct
   // result even for an unresolved type. We just need to look at all type
   // arguments and not just at the type parameters.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     len = cls.NumTypeParameters();  // Check the type parameters only.
+    if (len > num_type_args) {
+      // This type has the wrong number of arguments and is not finalized yet.
+      // Type arguments are reset to null when finalizing such a type.
+      ASSERT(!IsFinalized());
+      len = num_type_args;
+    }
   }
   return (len == 0) ||
          args.IsSubvectorInstantiated(num_type_args - len, len, genericity,
                                       trail);
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
@@ skipping 26 matching lines @@
   }
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators. Allocate a new instantiated version of it.
   const Type& instantiated_type =
       Type::Handle(zone, Type::New(cls, type_arguments, token_pos(), space));
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     instantiated_type.set_error(bound_error);
   }
-  // If this type is a function type, instantiate its signature.
+  // For a function type, possibly instantiate and set its signature.
   if (!sig_fun.IsNull()) {
-    // If we are finalizing a typedef, do not yet instantiate its signature.
-    // Other function types should never be instantiated while unfinalized.
+    // If we are finalizing a typedef, do not yet instantiate its signature,
+    // since it gets instantiated just before the type is marked as finalized.
+    // Other function types should never get instantiated while unfinalized,
+    // even while checking bounds of recursive types.
     if (IsFinalized()) {
       // A generic typedef may actually declare an instantiated signature.
       if (!sig_fun.HasInstantiatedSignature()) {
         sig_fun = sig_fun.InstantiateSignatureFrom(instantiator_type_arguments,
                                                    space);
       }
     } else {
-      ASSERT(cls.IsTypedefClass());
+      // The Kernel frontend does not keep the information that a function type
+      // is a typedef, so we cannot assert that cls.IsTypedefClass().
     }
     instantiated_type.set_signature(sig_fun);
   }
   if (IsFinalized()) {
     instantiated_type.SetIsFinalized();
   } else {
     instantiated_type.SetIsResolved();
     if (IsBeingFinalized()) {
       instantiated_type.SetIsBeingFinalized();
     }
@@ skipping 6129 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart