Stop postponing instantiation of Type and remove InstantiatedType VM class.

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 129 matching lines @@
   enum {
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
     kDynamicClass,
     kVoidClass,
     kUnresolvedClassClass,
     kTypeClass,
     kTypeParameterClass,
-    kInstantiatedTypeClass,
-    kAbstractTypeArgumentsClass,
     kTypeArgumentsClass,
     kInstantiatedTypeArgumentsClass,
     kFunctionClass,
     kFieldClass,
     kLiteralTokenClass,
     kTokenStreamClass,
     kScriptClass,
     kLibraryClass,
     kLibraryPrefixClass,
     kCodeClass,
@@ skipping 114 matching lines @@
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* null_class() { return null_class_; }
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* type_class() {
       return type_class_;
   }
   static RawClass* type_parameter_class() { return type_parameter_class_; }
-  static RawClass* instantiated_type_class() {
-      return instantiated_type_class_;
-  }
-  static RawClass* abstract_type_arguments_class() {
-    return abstract_type_arguments_class_;
-  }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
   static RawClass* instantiated_type_arguments_class() {
       return instantiated_type_arguments_class_;
   }
   static RawClass* function_class() { return function_class_; }
   static RawClass* field_class() { return field_class_; }
   static RawClass* literal_token_class() { return literal_token_class_; }
   static RawClass* token_stream_class() { return token_stream_class_; }
   static RawClass* script_class() { return script_class_; }
   static RawClass* library_class() { return library_class_; }
@@ skipping 93 matching lines @@
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   static RawClass* type_class_;  // Class of Type.
   static RawClass* type_parameter_class_;  // Class of TypeParameter vm object.
-  static RawClass* instantiated_type_class_;  // Class of InstantiatedType.
-  // Class of AbstractTypeArguments vm object.
-  static RawClass* abstract_type_arguments_class_;
   // Class of the TypeArguments vm object.
   static RawClass* type_arguments_class_;
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* field_class_;  // Class of the Field vm object.
   static RawClass* literal_token_class_;  // Class of LiteralToken vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
   static RawClass* library_class_;  // Class of the Library vm object.
   static RawClass* library_prefix_class_;  // Class of Library prefix vm object.
@@ skipping 366 matching lines @@
   void set_token_index(intptr_t token_index) const;
 
   static RawUnresolvedClass* New();
 
   HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractType is an abstract superclass.
-// Subclasses of AbstractType are Type, TypeParameter, and
-// InstantiatedType.
-//
-// Caution: 'RawAbstractType*' denotes a 'raw' pointer to a VM object of class
-// AbstractType, as opposed to 'AbstractType' denoting a 'handle' to the same
-// object. 'RawAbstractType' does not relate to a 'raw type', as opposed to a
-// 'cooked type' or 'rare type'.
+// Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Object {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
   virtual bool IsMalformed() const;
   virtual RawError* malformed_error() const;
   virtual void set_malformed_error(const Error& value) const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
@@ skipping 68 matching lines @@
   }
 
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractType& other, Error* malformed_error) const;
 
   static RawAbstractType* NewTypeParameter(const Class& parameterized_class,
                                            intptr_t index,
                                            const String& name,
                                            intptr_t token_index);
 
-  static RawAbstractType* NewInstantiatedType(
-      const AbstractType& uninstantiated_type,
-      const AbstractTypeArguments& instantiator_type_arguments);
-
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractType, Object);
   friend class Class;
 };
 
 
 // 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.
+//
+// Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
+// opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does not
+// relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
 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::kFinalizedInstantiated) ||
         (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated);
   }
@@ skipping 123 matching lines @@
   void set_name(const String& value) const;
   void set_token_index(intptr_t token_index) const;
   void set_type_state(int8_t state) const;
   static RawTypeParameter* New();
 
   HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
-// An instance of InstantiatedType is never encountered at compile time, but
-// only at run time, when type parameters can be matched to actual types.
-// An instance of InstantiatedType consists of an uninstantiated AbstractType
-// object and of a AbstractTypeArguments object. The type is uninstantiated,
-// because it refers to at least one TypeParameter object, i.e. to a type that
-// is not known at compile time.
-// The type argument vector is the instantiator, because each type parameter
-// with index i in the uninstantiated type can be substituted (or
-// "instantiated") with the type at index i in the type argument vector.
-class InstantiatedType : public AbstractType {
- public:
-  virtual bool IsFinalized() const { return true; }
-  virtual bool IsBeingFinalized() const { return false; }
-  virtual bool IsMalformed() const { return false; }
-  virtual bool IsResolved() const { return true; }
-  virtual bool HasResolvedTypeClass() const { return true; }
-  virtual RawClass* type_class() const;
-  virtual RawAbstractTypeArguments* arguments() const;
-  virtual intptr_t token_index() const;
-  virtual bool IsInstantiated() const { return true; }
-  virtual bool Equals(const AbstractType& other) const;
-
-  RawAbstractType* uninstantiated_type() const {
-    return raw_ptr()->uninstantiated_type_;
-  }
-  RawAbstractTypeArguments* instantiator_type_arguments() const {
-    return raw_ptr()->instantiator_type_arguments_;
-  }
-
-  static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawInstantiatedType));
-  }
-
-  static RawInstantiatedType* New(
-      const AbstractType& uninstantiated_type,
-      const AbstractTypeArguments& instantiator_type_arguments);
-
- private:
-  void set_uninstantiated_type(const AbstractType& value) const;
-  void set_instantiator_type_arguments(
-      const AbstractTypeArguments& value) const;
-  static RawInstantiatedType* New();
-
-  HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, AbstractType);
-  friend class Class;
-};
-
-
 // AbstractTypeArguments is an abstract superclass.
-// Subclasses of AbstractTypeArguments are TypeArguments and InstantiatedTypes.
+// Subclasses of AbstractTypeArguments are TypeArguments and
+// InstantiatedTypeArguments.
 class AbstractTypeArguments : public Object {
  public:
   // Returns true if both arguments represent vectors of equal types.
   static bool AreEqual(const AbstractTypeArguments& arguments,
                        const AbstractTypeArguments& other_arguments);
 
   // Returns true if both arguments represent vectors of possibly still
   // unresolved identical types.
   static bool AreIdentical(const AbstractTypeArguments& arguments,
                            const AbstractTypeArguments& other_arguments);
@@ skipping 3849 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_