Complete implementation of bounds checking in the vm, by introducing a vm object

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 634 matching lines @@
     set_type_arguments_field_offset_in_words(value);
   }
   void set_type_arguments_field_offset_in_words(intptr_t value) const {
     raw_ptr()->type_arguments_field_offset_in_words_ = value;
   }
   static intptr_t type_arguments_field_offset_in_words_offset() {
     return OFFSET_OF(RawClass, type_arguments_field_offset_in_words_);
   }
 
   // The super type of this class, Object type if not explicitly specified.
-  RawType* super_type() const { return raw_ptr()->super_type_; }
-  void set_super_type(const Type& value) const;
+  // Note that the super type may be bounded, as in this example:
+  // class C<T> extends S<T> { }; class S<T extends num> { };
+  RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
+  void set_super_type(const AbstractType& value) const;
   static intptr_t super_type_offset() {
     return OFFSET_OF(RawClass, super_type_);
   }
 
   // Asserts that the class of the super type has been resolved.
   RawClass* SuperClass() const;
 
   RawType* mixin() const { return raw_ptr()->mixin_; }
   void set_mixin(const Type& value) const;
 
@@ skipping 277 matching lines @@
 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.
+  // If malformed_error is not NULL, it may be set to reflect a bound error.
   virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments) const;
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) 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>, Smi>".
   virtual RawString* Name() const {
     return SubvectorName(0, Length(), kInternalName);
   }
 
   // The name of this type argument vector, e.g. "<T, dynamic, List<T>, int>".
   // Names of internal classes are mapped to their public interfaces.
   virtual RawString* UserVisibleName() const {
     return SubvectorName(0, Length(), kUserVisibleName);
   }
 
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
   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. 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 {
     return TypeTest(kIsSubtypeOf, other, len, malformed_error);
   }
 
   // Check the 'more specific' relationship, considering only a prefix of
   // length 'len'.
   bool IsMoreSpecificThan(const AbstractTypeArguments& other,
                           intptr_t len,
                           Error* malformed_error) const {
     return TypeTest(kIsMoreSpecificThan, other, len, malformed_error);
   }
 
   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;
+  virtual bool IsBounded() const;
 
   virtual intptr_t Hash() 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;
 
@@ skipping 22 matching lines @@
  public:
   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;
+  virtual bool IsBounded() const;
   // Canonicalize only if instantiated, otherwise returns 'this'.
   virtual RawAbstractTypeArguments* Canonicalize() const;
 
   virtual RawAbstractTypeArguments* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments) const;
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) const;
 
   static const intptr_t kBytesPerElement = kWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t length_offset() {
     return OFFSET_OF(RawTypeArguments, length_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTypeArguments) == OFFSET_OF(RawTypeArguments, types_));
@@ skipping 30 matching lines @@
 // parameter with index i in the first vector can be substituted (or
 // "instantiated") with the type at index i in the second type argument vector.
 class InstantiatedTypeArguments : 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 { return true; }
   virtual bool IsInstantiated() const { return true; }
   virtual bool IsUninstantiatedIdentity() const  { return false; }
+  virtual bool IsBounded() const { return false; }  // Bounds were checked.
 
   RawAbstractTypeArguments* uninstantiated_type_arguments() const {
     return raw_ptr()->uninstantiated_type_arguments_;
   }
   static intptr_t uninstantiated_type_arguments_offset() {
     return OFFSET_OF(RawInstantiatedTypeArguments,
                      uninstantiated_type_arguments_);
   }
 
   RawAbstractTypeArguments* instantiator_type_arguments() const {
@@ skipping 2271 matching lines @@
   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 Instance& other) const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
+  // If malformed_error is not NULL, it may be set to reflect a bound error.
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments) const;
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) 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 {
     return BuildName(kInternalName);
   }
 
   // The name of this type, including the names of its type arguments, if any.
@@ skipping 105 matching lines @@
   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 Instance& other) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments) const;
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) const;
   virtual RawAbstractType* Canonicalize() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
@@ skipping 55 matching lines @@
 
 // A TypeParameter represents a type parameter of a parameterized class.
 // 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.
+// to the ObjectType.
 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_;
   }
   RawString* name() const { return raw_ptr()->name_; }
   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;
+  void CheckBound(const AbstractType& bounded_type,
+                  const AbstractType& upper_bound,
+                  Error* malformed_error) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const { return false; }
   virtual bool Equals(const Instance& other) const;
   virtual RawAbstractType* InstantiateFrom(
-      const AbstractTypeArguments& instantiator_type_arguments) const;
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) const;
   virtual RawAbstractType* Canonicalize() const { return raw(); }
 
   virtual intptr_t Hash() const;
 
   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();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
+// A BoundedType represents a type instantiated at compile time from a type
+// parameter specifying a bound that either cannot be checked at compile time
+// because the type or the bound are still uninstantiated or can be checked and
+// would trigger a bound error in checked mode. The bound must be checked at
+// runtime once the type and its bound are instantiated and when the execution
+// mode is known to be checked mode.
+class BoundedType : public AbstractType {
+ public:
+  virtual bool IsFinalized() const {
+    return AbstractType::Handle(type()).IsFinalized();
+  }
+  virtual bool IsBeingFinalized() const {
+    return AbstractType::Handle(type()).IsBeingFinalized();
+  }
+  virtual bool IsMalformed() const;
+  virtual RawError* malformed_error() const;
+  virtual bool IsResolved() const { return true; }
+  virtual bool HasResolvedTypeClass() const {
+    return AbstractType::Handle(type()).HasResolvedTypeClass();
+  }
+  virtual RawClass* type_class() const {
+    return AbstractType::Handle(type()).type_class();
+  }
+  virtual RawUnresolvedClass* unresolved_class() const {
+    return AbstractType::Handle(type()).unresolved_class();
+  }
+  virtual RawAbstractTypeArguments* arguments() const {
+    return AbstractType::Handle(type()).arguments();
+  }
+  RawAbstractType* type() const { return raw_ptr()->type_; }
+  RawAbstractType* bound() const { return raw_ptr()->bound_; }
+  RawTypeParameter* type_parameter() const {
+    return raw_ptr()->type_parameter_;
+  }
+  virtual intptr_t token_pos() const {
+    return AbstractType::Handle(type()).token_pos();
+  }
+  virtual bool IsInstantiated() const {
+    return AbstractType::Handle(type()).IsInstantiated();
+  }
+  virtual bool Equals(const Instance& other) const;
+  virtual RawAbstractType* InstantiateFrom(
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* malformed_error) const;
+  virtual RawAbstractType* Canonicalize() const { return raw(); }
+
+  virtual intptr_t Hash() const;
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawBoundedType));
+  }
+
+  static RawBoundedType* New(const AbstractType& type,
+                             const AbstractType& bound,
+                             const TypeParameter& type_parameter);
+
+ private:
+  void set_type(const AbstractType& value) const;
+  void set_bound(const AbstractType& value) const;
+  void set_type_parameter(const TypeParameter& value) const;
+
+  bool is_being_checked() const {
+    return raw_ptr()->is_being_checked_;
+  }
+  void set_is_being_checked(bool value) const;
+
+  static RawBoundedType* New();
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(BoundedType, AbstractType);
+  friend class Class;
+};
+
+
 class Number : public Instance {
  public:
   // TODO(iposva): Fill in a useful Number interface.
   virtual bool IsZero() const {
     // Number is an abstract class.
     UNREACHABLE();
     return false;
   }
   virtual bool IsNegative() const {
     // Number is an abstract class.
@@ skipping 2898 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_