Mark types as instantiated or uninstantiated upon finalization.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 867 matching lines @@
 
 // A Type consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 class Type : public AbstractType {
  public:
   static intptr_t type_class_offset() {
     return OFFSET_OF(RawType, type_class_);
   }
   virtual bool IsFinalized() const {
-    return raw_ptr()->type_state_ == RawType::kFinalized;
+    return
+        (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) ||
+        (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated);
   }
-  void set_is_finalized() const;
+  void set_is_finalized_instantiated() const;
+  void set_is_finalized_uninstantiated() const;
   virtual bool IsBeingFinalized() const {
     return raw_ptr()->type_state_ == RawType::kBeingFinalized;
   }
   void set_is_being_finalized() const;
   virtual bool IsMalformed() const;
   virtual RawError* malformed_error() const;
   virtual void set_malformed_error(const Error& value) const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
@@ skipping 68 matching lines @@
 // A TypeParameter represents a type parameter of a parameterized class.
 // It specifies its index (and its name for debugging purposes).
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
 // Upon finalization, the TypeParameter index is changed to reflect its position
 // as type argument (rather than type parameter) of the parameterized class.
 class TypeParameter : public AbstractType {
  public:
   virtual bool IsFinalized() const {
-    return raw_ptr()->type_state_ == RawTypeParameter::kFinalized;
+    return raw_ptr()->type_state_ == RawTypeParameter::kFinalizedUninstantiated;

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

Assert somewhere that is is not kFinalizedInstantiated?

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

Done.

   }
   void set_is_finalized() const;
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsMalformed() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   RawClass* parameterized_class() const {
       return raw_ptr()->parameterized_class_;
   }
   virtual RawString* Name() const { return raw_ptr()->name_; }
@@ skipping 3006 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_