Mark types as instantiated or uninstantiated upon finalization.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 980 matching lines @@
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
 void Class::set_class_state(int8_t state) const {
-  ASSERT(state == RawClass::kAllocated ||
-         state == RawClass::kPreFinalized ||
-         state == RawClass::kFinalized);
+  ASSERT((state == RawClass::kAllocated) ||
+         (state == RawClass::kPreFinalized) ||
+         (state == RawClass::kFinalized));
   raw_ptr()->class_state_ = state;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
@@ skipping 1252 matching lines @@
 
 
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(Object::Handle(type_class.raw()),
                     no_type_arguments,
                     Scanner::kDummyTokenIndex);
-  type.set_is_finalized();
+  type.set_is_finalized_instantiated();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
-void Type::set_is_finalized() const {
+void Type::set_is_finalized_instantiated() const {
   ASSERT(!IsFinalized());
-  set_type_state(RawType::kFinalized);
+  set_type_state(RawType::kFinalizedInstantiated);
+}
+
+
+void Type::set_is_finalized_uninstantiated() const {
+  ASSERT(!IsFinalized());
+  set_type_state(RawType::kFinalizedUninstantiated);
 }
 
 
 void Type::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
 
 
 bool Type::IsMalformed() const {
@@ skipping 58 matching lines @@
   }
 }
 
 
 RawAbstractTypeArguments* Type::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
 bool Type::IsInstantiated() const {
+  if (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) {
+    return true;
+  }
+  if (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated) {
+    return false;
+  }
   const AbstractTypeArguments& args =

[srdjan, 2012/04/24 00:56:28]

Can IsInstantiated be true if the type is not finalized?

[regis, 2012/04/24 16:06:58]

Yes. We call IsInstantiated() on a type before marking it as
kFinalizedInstantiated or kFinalizedUninstantiated.

       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
   Type& instantiated_type = Type::Handle(
       Type::New(cls, type_arguments, token_index()));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
-  instantiated_type.set_is_finalized();
+  instantiated_type.set_is_finalized_instantiated();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
   if (IsMalformed() || !other.IsType() || other.IsMalformed()) {
@@ skipping 111 matching lines @@
 }
 
 
 void Type::set_token_index(intptr_t token_index) const {
   ASSERT(token_index >= 0);
   raw_ptr()->token_index_ = token_index;
 }
 
 
 void Type::set_type_state(int8_t state) const {
-  ASSERT(state == RawType::kAllocated ||
-         state == RawType::kBeingFinalized ||
-         state == RawType::kFinalized);
+  ASSERT((state == RawType::kAllocated) ||
+         (state == RawType::kBeingFinalized) ||
+         (state == RawType::kFinalizedInstantiated) ||
+         (state == RawType::kFinalizedUninstantiated));
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(arguments());
     if (type_arguments.IsNull()) {
       const char* format = "Type: class '%s'";
@@ skipping 17 matching lines @@
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
-  set_type_state(RawTypeParameter::kFinalized);
+  set_type_state(RawTypeParameter::kFinalizedUninstantiated);
   // Field parameterized_class_ is not needed after finalization anymore.
   set_parameterized_class(Class::Handle());
 }
 
 
 bool TypeParameter::Equals(const AbstractType& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
@@ skipping 85 matching lines @@
 }
 
 
 void TypeParameter::set_token_index(intptr_t token_index) const {
   ASSERT(token_index >= 0);
   raw_ptr()->token_index_ = token_index;
 }
 
 
 void TypeParameter::set_type_state(int8_t state) const {
-  ASSERT(state == RawTypeParameter::kAllocated ||
-         state == RawTypeParameter::kBeingFinalized ||
-         state == RawTypeParameter::kFinalized);
+  ASSERT((state == RawTypeParameter::kAllocated) ||
+         (state == RawTypeParameter::kBeingFinalized) ||
+         (state == RawTypeParameter::kFinalizedUninstantiated));
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* format = "TypeParameter: name %s; index: %d";
   const char* name_cstr = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, Index()) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
@@ skipping 3873 matching lines @@
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
   const Type& type = Type::Handle(
       Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
-  type.set_is_finalized();
+  type.set_is_finalized_instantiated();
   return type.raw();
 }
 
 
 RawAbstractTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   type_arguments ^= *FieldAddrAtOffset(field_offset);
@@ skipping 2653 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart