Represent declared type parameters of a class as an array of TypeParameter

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 459 matching lines @@
   // Return the signature type of this signature class.
   // For example, if this class represents a signature of the form
   // '<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
   // type with this class as the type class and type parameters 'T' and 'R'
   // as its type argument vector.
   RawType* SignatureType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
-  // The type parameters are specified as an array of Strings.
-  // TODO(regis): Store them as an array of TypeParameter with token_index.
-  RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
-  void set_type_parameters(const Array& value) const;
+  // The type parameters are specified as an array of TypeParameter.
+  RawTypeArguments* type_parameters() const {
+      return raw_ptr()->type_parameters_;
+  }
+  void set_type_parameters(const TypeArguments& value) const;
   intptr_t NumTypeParameters() const;
 
-  // Type parameters may optionally extend a Type (Dynamic if no extends).
-  // TODO(regis): Should it be Object instead of Dynamic?
-  RawTypeArguments* type_parameter_extends() const {
-    return raw_ptr()->type_parameter_extends_;
+  // Type parameter bounds (implicitly Dynamic if not explicitly specified) as
+  // an array of AbstractType.
+  RawTypeArguments* type_parameter_bounds() const {
+    return raw_ptr()->type_parameter_bounds_;
   }
-  void set_type_parameter_extends(const TypeArguments& value) const;
+  void set_type_parameter_bounds(const TypeArguments& value) const;
 
   // Return a TypeParameter if the type_name is a type parameter of this class.
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name,
                                         intptr_t token_index) const;
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   bool HasTypeArguments() const;
   intptr_t NumTypeArguments() const;
@@ skipping 24 matching lines @@
   // Return the resolved factory class of this interface.
   RawClass* FactoryClass() const;
 
   // Return the unresolved factory class of this interface.
   RawUnresolvedClass* UnresolvedFactoryClass() const;
 
   // Set the resolved or unresolved factory class of this interface.
   void set_factory_class(const Object& value) const;
 
   // Interfaces is an array of Types.
-  // TODO(srdjan): Return TypeArguments instead of Array?
   RawArray* interfaces() const { return raw_ptr()->interfaces_; }
   void set_interfaces(const Array& value) const;
 
   RawArray* functions_cache() const { return raw_ptr()->functions_cache_; }
   void set_functions_cache(const Array& value) const;
 
   static intptr_t functions_cache_offset() {
     return OFFSET_OF(RawClass, functions_cache_);
   }
 
@@ skipping 387 matching lines @@
 
   // The 'String' interface type.
   static RawType* StringInterface();
 
   // The 'Function' interface type.
   static RawType* FunctionInterface();
 
   // The 'List' interface type.
   static RawType* ListInterface();
 
-  // The least specific valid raw type of the given class.
-  // For example, type A<Dynamic> would be returned for class A<T>, and type
-  // B<Dynamic, A<Dynamic>> would be returned for B<U, V extends A>.
-  static RawType* NewRawType(const Class& type_class, intptr_t token_index);
-
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* New(const Object& clazz,
                       const AbstractTypeArguments& arguments,
                       intptr_t token_index);
 
  private:
   void set_token_index(intptr_t token_index) const;
   void set_type_state(int8_t state) const;
@@ skipping 131 matching lines @@
   virtual bool IsResolved() const;
   virtual bool IsInstantiated() const;
   virtual bool IsUninstantiatedIdentity() const;
 
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
   friend class Class;
 };
 
 
-// A TypeArguments is simply an array of Types.
+// A TypeArguments is an array of AbstractType.
 class TypeArguments : public AbstractTypeArguments {
  public:
   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;
   // Canonicalize only if instantiated, otherwise returns 'this'.
   virtual RawAbstractTypeArguments* Canonicalize() const;
@@ skipping 2537 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_