Mark types as instantiated or uninstantiated upon finalization.

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 682 matching lines @@
       } 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.
-    parameterized_type.set_is_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();
       }
     }
   } else {
-    parameterized_type.set_is_finalized();
+    // Mark the type as finalized.
+    if (parameterized_type.IsInstantiated()) {
+      parameterized_type.set_is_finalized_instantiated();
+    } else {
+      parameterized_type.set_is_finalized_uninstantiated();
+    }
   }
   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;
@@ skipping 555 matching lines @@
     // In production mode, mark the type as malformed only if its type class is
     // not resolved.
     type.set_malformed_error(error);
   } else {
      // In production mode, do not mark the type with a resolved type class as
      // malformed, but make it raw.
     ASSERT(type.HasResolvedTypeClass());
     type.set_arguments(AbstractTypeArguments::Handle());
   }
   if (!type.IsFinalized()) {
-    type.set_is_finalized();
+    type.set_is_finalized_instantiated();
     // Do not canonicalize malformed types, since they may not be resolved.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
@@ skipping 16 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