Use null type argument vector instead of vector of Dynamic for a generic raw

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 830 matching lines @@
     if (!HasResolvedTypeClass()) {
       return false;
     }
     const Class& cls = Class::Handle(type_class());
     return !cls.IsNull() && cls.is_interface();
   }
 
   // Check the subtype relationship.
   bool IsSubtypeOf(const AbstractType& other, Error* malformed_error) const;
 
-  static RawAbstractType* NewTypeParameter(intptr_t index,
+  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;
@@ skipping 81 matching lines @@
   void set_token_index(intptr_t token_index) const;
   void set_type_state(int8_t state) const;
 
   static RawType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
-// A TypeParameter, in the context of a parameterized class, references a type
-// parameter of a class by its index (and by its name for debugging purposes).
+// 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 enclosing class.
+// 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;
   }
   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_; }
   virtual intptr_t Index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
   virtual intptr_t token_index() const { return raw_ptr()->token_index_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const { return raw(); }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
-  static RawTypeParameter* New(intptr_t index,
+  static RawTypeParameter* New(const Class& parameterized_class,
+                               intptr_t index,
                                const String& name,
                                intptr_t token_index);
 
  private:
+  void set_parameterized_class(const Class& value) const;
   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;
 };
 
 
@@ skipping 41 matching lines @@
 
   HEAP_OBJECT_IMPLEMENTATION(InstantiatedType, AbstractType);
   friend class Class;
 };
 
 
 // AbstractTypeArguments is an abstract superclass.
 // Subclasses of AbstractTypeArguments are TypeArguments and InstantiatedTypes.
 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);
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
   // type of the instantiator type argument vector.
   virtual RawAbstractTypeArguments* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Do not canonicalize InstantiatedTypeArguments or NULL objects
   virtual RawAbstractTypeArguments* Canonicalize() const { return this->raw(); }
 
+  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, int>".
+  virtual RawString* Name() const {
+    return SubvectorName(0, Length());
+  }
+
+  // The name of a subvector of this type argument vector, e.g. "<T, Dynamic>".
+  virtual RawString* SubvectorName(intptr_t from_index, intptr_t len) const;
+
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
-  bool IsDynamicTypes(intptr_t len) const;
+  bool IsRaw(intptr_t len) const {
+    return IsDynamicTypes(false, len);
+  }
+
+  // Check if this type argument vector would consist solely of DynamicType if
+  // it was instantiated from a raw (null) instantiator, i.e. consider each type
+  // parameter as it would be first instantiated from a vector of dynamic types.
+  // Consider only a prefix of length 'len'.
+  bool IsRawInstantiatedRaw(intptr_t len) const {
+    return IsDynamicTypes(true, len);
+  }
 
   // Check that this type argument vector is within the declared bounds of the
   // given class or interface. If not, set malformed_error (if not yet set).
   bool IsWithinBoundsOf(const Class& cls,
                         const AbstractTypeArguments& bounds_instantiator,
                         Error* malformed_error) const;
 
   // Check the subtype relationship, considering only a prefix of length 'len'.
   bool IsSubtypeOf(const AbstractTypeArguments& other,
                    intptr_t len,
                    Error* malformed_error) const;
 
   bool Equals(const AbstractTypeArguments& other) const;
 
   // UNREACHABLEs as AbstractTypeArguments is an abstract class.
   virtual intptr_t Length() const;
   virtual RawAbstractType* TypeAt(intptr_t index) const;
   virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
 
+ private:
+  // Check if this type argument vector consists solely of DynamicType,
+  // considering only a prefix of length 'len'.
+  // If raw_instantiated is true, consider each type parameter to be first
+  // instantiated from a vector of dynamic types.
+  bool IsDynamicTypes(bool raw_instantiated, intptr_t len) const;
+
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
   friend class Class;
 };
 
 
 // A TypeArguments is an array of AbstractType.
 class TypeArguments : public AbstractTypeArguments {
  public:
+  // Returns true if both arguments represent identical vectors of type
+  // parameters, in number and names (but the type class may be different).
+  static bool AreIdenticalTypeParameters(const TypeArguments& arguments,
+                                         const TypeArguments& other_arguments);
+
   virtual intptr_t Length() const;
   virtual RawAbstractType* TypeAt(intptr_t index) const;
   static intptr_t type_at_offset(intptr_t index) {
     return OFFSET_OF(RawTypeArguments, types_) + index * kWordSize;
   }
   virtual void SetTypeAt(intptr_t index, const AbstractType& value) const;
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
   // Canonicalize only if instantiated, otherwise returns 'this'.
@@ skipping 2807 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_