Allow self referencing typedefs (issue 2490).

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 670 matching lines @@
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
       type_argument = FinalizeType(cls, type_argument, finalization);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 
-  // If the type class is a signature class, we are finalizing its signature
-  // type, thereby finalizing the result type and parameter types of its
-  // signature function.
-  // Do this before marking this type as finalized in order to detect cycles.
-  if (type_class.IsSignatureClass()) {
-    // Signature classes are finalized upon creation.
-    ASSERT(type_class.is_finalized());
-    // Resolve and finalize the result and parameter types of the signature
-    // function of this signature class.
-    ResolveAndFinalizeSignature(
-        type_class, Function::Handle(type_class.signature_function()));
-  }
-
-  // Illegally self referencing function types may get finalized indirectly.
-  if (parameterized_type.IsFinalized()) {
-    ASSERT(parameterized_type.IsMalformed());
-    return parameterized_type.raw();
-  }
-
   // The finalized type argument vector needs num_type_arguments types.
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, type parameter bounds are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
     // Wrong number of type arguments. The type is malformed.
     FinalizeMalformedType(
         Error::Handle(),  // No previous error.
         cls, parameterized_type, finalization,
         "wrong number of type arguments in type '%s'",
         String::Handle(parameterized_type.Name()).ToCString());
     return parameterized_type.raw();
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
+  TypeArguments& full_arguments = TypeArguments::Handle();
   if (num_type_arguments > 0) {
-    TypeArguments& full_arguments = TypeArguments::Handle();
     // If no type arguments were parsed and if the super types do not prepend
     // type arguments to the vector, we can leave the vector as null.
     if (!arguments.IsNull() || (num_type_arguments > num_type_parameters)) {
       full_arguments = TypeArguments::New(num_type_arguments);
       // Copy the parsed type arguments at the correct offset in the full type
       // argument vector.
       const intptr_t offset = num_type_arguments - num_type_parameters;
       AbstractType& type_arg = AbstractType::Handle(Type::DynamicType());
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         // If no type parameters were provided, a raw type is desired, so we
@@ skipping 19 matching lines @@
         full_arguments = TypeArguments::null();
       } else {
         // FinalizeTypeArguments can modify 'full_arguments',
         // canonicalize afterwards.
         full_arguments ^= full_arguments.Canonicalize();
       }
       parameterized_type.set_arguments(full_arguments);
     } else {
       ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
-    // Mark the type as finalized.
-    if (parameterized_type.IsInstantiated()) {
-      parameterized_type.set_is_finalized_instantiated();
-    } else {
-      parameterized_type.set_is_finalized_uninstantiated();
-    }
+  }
 
-    // Upper bounds of the finalized type arguments are only verified in checked
-    // mode, since bound errors are never reported by the vm in production mode.
-    if (FLAG_enable_type_checks &&
-        !full_arguments.IsNull() &&
-        full_arguments.IsInstantiated()) {
-      ResolveAndFinalizeUpperBounds(type_class);
-      Error& malformed_error = Error::Handle();
-      // Pass the full type argument vector as the bounds instantiator.
-      if (!full_arguments.IsWithinBoundsOf(type_class,
-                                           full_arguments,
-                                           &malformed_error)) {
-        ASSERT(!malformed_error.IsNull());
-        // The type argument vector of the type is not within bounds. The type
-        // is malformed. Prepend malformed_error to new malformed type error in
-        // order to report both locations.
-        // Note that malformed bounds never result in a compile time error, even
-        // in checked mode. Therefore, overwrite finalization with kFinalize
-        // when finalizing the malformed type.
-        FinalizeMalformedType(
-            malformed_error,
-            cls, parameterized_type, kFinalize,
-            "type arguments of type '%s' are not within bounds",
-            String::Handle(parameterized_type.Name()).ToCString());
-        return parameterized_type.raw();
-      }
-    }
+  // Illegally self referencing types may get finalized indirectly.
+  if (parameterized_type.IsFinalized()) {
+    ASSERT(parameterized_type.IsMalformed());
   } else {
     // Mark the type as finalized.
     if (parameterized_type.IsInstantiated()) {
       parameterized_type.set_is_finalized_instantiated();
     } else {
       parameterized_type.set_is_finalized_uninstantiated();
     }
   }
+
+  // Upper bounds of the finalized type arguments are only verified in checked
+  // mode, since bound errors are never reported by the vm in production mode.
+  if (FLAG_enable_type_checks &&
+      !full_arguments.IsNull() &&
+      full_arguments.IsInstantiated()) {
+    ResolveAndFinalizeUpperBounds(type_class);
+    Error& malformed_error = Error::Handle();
+    // Pass the full type argument vector as the bounds instantiator.
+    if (!full_arguments.IsWithinBoundsOf(type_class,
+                                         full_arguments,
+                                         &malformed_error)) {
+      ASSERT(!malformed_error.IsNull());
+      // The type argument vector of the type is not within bounds. The type
+      // is malformed. Prepend malformed_error to new malformed type error in
+      // order to report both locations.
+      // Note that malformed bounds never result in a compile time error, even
+      // in checked mode. Therefore, overwrite finalization with kFinalize
+      // when finalizing the malformed type.
+      FinalizeMalformedType(
+          malformed_error,
+          cls, parameterized_type, kFinalize,
+          "type arguments of type '%s' are not within bounds",
+          String::Handle(parameterized_type.Name()).ToCString());
+      return parameterized_type.raw();
+    }
+  }
+
+  // If the type class is a signature class, we also finalize its signature
+  // type, thereby finalizing the result type and parameter types of its
+  // signature function.
+  // We do this after marking this type as finalized in order to allow a
+  // function type to refer to itself via its parameter types and result type.
+  if (type_class.IsSignatureClass()) {
+    // Signature classes are finalized upon creation.
+    ASSERT(type_class.is_finalized());
+    // Resolve and finalize the result and parameter types of the signature
+    // function of this signature class.
+    ResolveAndFinalizeSignature(
+        type_class, Function::Handle(type_class.signature_function()));
+  }
+
   return parameterized_type.Canonicalize();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   FinalizationKind result_finalization = kFinalize;
   if (function.IsFactory()) {
@@ skipping 591 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart