Consider upper bounds of type parameters in type checks.

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 486 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 TypeParameter.
+  // The type parameters (and their bounds) 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;
   static intptr_t type_parameters_offset() {
     return OFFSET_OF(RawClass, type_parameters_);
   }
 
-  // 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_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_pos) const;
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   bool HasTypeArguments() const;
   intptr_t NumTypeArguments() const;
 
@@ skipping 290 matching lines @@
   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;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawAbstractTypeArguments* arguments() const;
   virtual intptr_t token_pos() const;
   virtual bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
-  virtual bool IsIdentical(const AbstractType& other) const;
+  virtual bool IsIdentical(const AbstractType& other,
+                           bool check_type_parameter_bound) const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Return the canonical version of this type.
   virtual RawAbstractType* Canonicalize() const;
 
   // The name of this type, including the names of its type arguments, if any.
   virtual RawString* Name() const;
 
-  // The index of this type parameter. Fail if not a type parameter.
-  virtual intptr_t Index() const;
-
   // The name of this type's class, i.e. without the type argument names of this
   // type.
   RawString* ClassName() const;
 
   // Check if this type represents the 'Dynamic' type.
   bool IsDynamicType() const {
     return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
   }
 
   // Check if this type represents the 'Null' type.
@@ skipping 95 matching lines @@
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   RawString* TypeClassName() const;
   virtual RawAbstractTypeArguments* arguments() const;
   void set_arguments(const AbstractTypeArguments& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const;
   virtual bool Equals(const AbstractType& other) const;
-  virtual bool IsIdentical(const AbstractType& other) const;
+  virtual bool IsIdentical(const AbstractType& other,
+                           bool check_type_parameter_bound) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
@@ skipping 40 matching lines @@
   void set_type_state(int8_t state) const;
 
   static RawType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
 // A TypeParameter represents a type parameter of a parameterized class.
-// It specifies its index (and its name for debugging purposes).
+// It specifies its index (and its name for debugging purposes), as well as its
+// upper bound.
 // 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.
+// If the type parameter is declared without an extends clause, its bound is set
+// to the DynamicType.
 class TypeParameter : public AbstractType {
  public:
   virtual bool IsFinalized() const {
     ASSERT(raw_ptr()->type_state_ != RawTypeParameter::kFinalizedInstantiated);
     return raw_ptr()->type_state_ == RawTypeParameter::kFinalizedUninstantiated;
   }
   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_; }
+  intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
+  RawAbstractType* bound() const { return raw_ptr()->bound_; }
+  void set_bound(const AbstractType& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const AbstractType& other) const;
-  virtual bool IsIdentical(const AbstractType& other) const;
+  virtual bool IsIdentical(const AbstractType& other,
+                           bool check_type_parameter_bound) 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(const Class& parameterized_class,
                                intptr_t index,
                                const String& name,
+                               const AbstractType& bound,
                                intptr_t token_pos);
 
  private:
   void set_parameterized_class(const Class& value) const;
   void set_name(const String& value) const;
   void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
   static RawTypeParameter* New();
 
   HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // AbstractTypeArguments is an abstract superclass.
 // 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);
+                           const AbstractTypeArguments& other_arguments,
+                           bool check_type_parameter_bounds);
 
   // 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(); }
@@ skipping 3985 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_