Implement stricter rule about self referencing typedefs (fix issue 13675).

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 566 matching lines @@
     AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle();
     if (super_type.IsBeingFinalized()) {
       // This type references itself via its type arguments. This is legal, but
       // we must avoid endless recursion. We therefore map the innermost
       // super type to dynamic.
       // Note that a direct self-reference via the super class chain is illegal
       // and reported as an error earlier.
       // Such legal self-references occur with F-bounded quantification.
       // Example 1: class Derived extends Base<Derived>.
       // The type 'Derived' forms a cycle by pointing to itself via its
-      // flattened type argument vector: Derived[Base[Derived[Base[...]]]]
-      // We break the cycle as follows: Derived[Base[Derived[dynamic]]]
+      // flattened type argument vector: Derived[Derived[...]]
+      // We break the cycle as follows: Derived[Derived[dynamic]]
       // Example 2: class Derived extends Base<Middle<Derived>> results in
-      // Derived[Base[Middle[Derived[dynamic]]]]
+      // Derived[Middle[Derived[dynamic]]]
       // Example 3: class Derived<T> extends Base<Derived<T>> results in
-      // Derived[Base[Derived[dynamic]], T].
+      // Derived[Derived[dynamic], T].
       ASSERT(super_type_args.IsNull());  // Same as a vector of dynamic.
     } else {
       super_type ^= FinalizeType(cls, super_type, finalization);
       cls.set_super_type(super_type);
       super_type_args = super_type.arguments();
     }
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumOwnTypeArguments()));
@@ skipping 1517 matching lines @@
     if (!test2.IsNull()) {
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
 
 // Helper function called by IsAliasCycleFree.
-bool ClassFinalizer::IsParameterTypeCycleFree(
+bool ClassFinalizer::IsTypeCycleFree(
     const Class& cls,
     const AbstractType& type,
     GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   ResolveType(cls, type, kCanonicalize);
   if (type.IsType() && !type.IsMalformed()) {
     const Class& type_class = Class::Handle(type.type_class());
     if (!type_class.is_type_finalized() &&
         type_class.IsSignatureClass() &&
         !IsAliasCycleFree(type_class, visited)) {
       return false;
     }
     const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
         type.arguments());
     if (!type_args.IsNull()) {
       AbstractType& type_arg = AbstractType::Handle();
       for (intptr_t i = 0; i < type_args.Length(); i++) {
         type_arg = type_args.TypeAt(i);
-        if (!IsParameterTypeCycleFree(cls, type_arg, visited)) {
+        if (!IsTypeCycleFree(cls, type_arg, visited)) {
           return false;
         }
       }
     }
   }
   return true;
 }
 
 
 // Returns false if the function type alias illegally refers to itself.
 bool ClassFinalizer::IsAliasCycleFree(const Class& cls,
                                       GrowableArray<intptr_t>* visited) {
   ASSERT(cls.IsSignatureClass());
   ASSERT(!cls.is_type_finalized());
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited alias 'cls'. We found a cycle.
       return false;
     }
   }
 
-  // Visit the result type and parameter types of this signature type.
+  // Visit the bounds, result type, and parameter types of this signature type.
   visited->Add(cls.id());
+  AbstractType& type = AbstractType::Handle();
+
+  // Check the bounds of this signature type.
+  const intptr_t num_type_params = cls.NumTypeParameters();
+  TypeParameter& type_param = TypeParameter::Handle();
+  const AbstractTypeArguments& type_params =
+      AbstractTypeArguments::Handle(cls.type_parameters());
+  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
+         (type_params.Length() == num_type_params));
+  for (intptr_t i = 0; i < num_type_params; i++) {
+    type_param ^= type_params.TypeAt(i);
+    type = type_param.bound();
+    if (!IsTypeCycleFree(cls, type, visited)) {
+      return false;
+    }
+  }
+  // Check the result type of the function of this signature type.
   const Function& function = Function::Handle(cls.signature_function());
-  // Check class of result type.
-  AbstractType& type = AbstractType::Handle(function.result_type());
-  if (!IsParameterTypeCycleFree(cls, type, visited)) {
+  type = function.result_type();
+  if (!IsTypeCycleFree(cls, type, visited)) {
     return false;
   }
-  // Check classes of formal parameter types.
+  // Check the formal parameter types of the function of this signature type.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
-    if (!IsParameterTypeCycleFree(cls, type, visited)) {
+    if (!IsTypeCycleFree(cls, type, visited)) {
       return false;
     }
   }
   visited->RemoveLast();
   return true;
 }
 
 
 // Returns false if the mixin illegally refers to itself.
 bool ClassFinalizer::IsMixinCycleFree(const Class& cls,
@@ skipping 550 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart