Index: runtime/vm/object.h |
=================================================================== |
--- runtime/vm/object.h (revision 32446) |
+++ runtime/vm/object.h (working copy) |
@@ -358,9 +358,9 @@ |
ASSERT(null_instance_ != NULL); |
return *null_instance_; |
} |
- static const AbstractTypeArguments& null_abstract_type_arguments() { |
- ASSERT(null_abstract_type_arguments_ != NULL); |
- return *null_abstract_type_arguments_; |
+ static const TypeArguments& null_type_arguments() { |
+ ASSERT(null_type_arguments_ != NULL); |
+ return *null_type_arguments_; |
} |
static const Array& empty_array() { |
@@ -427,9 +427,6 @@ |
static RawType* void_type() { return void_type_; } |
static RawClass* unresolved_class_class() { return unresolved_class_class_; } |
static RawClass* type_arguments_class() { return type_arguments_class_; } |
- static RawClass* instantiated_type_arguments_class() { |
- return instantiated_type_arguments_class_; |
- } |
static RawClass* patch_class_class() { return patch_class_class_; } |
static RawClass* function_class() { return function_class_; } |
static RawClass* closure_data_class() { return closure_data_class_; } |
@@ -580,9 +577,7 @@ |
static RawType* dynamic_type_; // Class of the 'dynamic' type. |
static RawType* void_type_; // Class of the 'void' type. |
static RawClass* unresolved_class_class_; // Class of UnresolvedClass. |
- // Class of the TypeArguments vm object. |
- static RawClass* type_arguments_class_; |
- static RawClass* instantiated_type_arguments_class_; // Class of Inst..ments. |
+ static RawClass* type_arguments_class_; // Class of TypeArguments vm object. |
static RawClass* patch_class_class_; // Class of the PatchClass vm object. |
static RawClass* function_class_; // Class of the Function vm object. |
static RawClass* closure_data_class_; // Class of ClosureData vm obj. |
@@ -617,7 +612,7 @@ |
static Array* null_array_; |
static String* null_string_; |
static Instance* null_instance_; |
- static AbstractTypeArguments* null_abstract_type_arguments_; |
+ static TypeArguments* null_type_arguments_; |
static Array* empty_array_; |
static PcDescriptors* empty_descriptors_; |
static Instance* sentinel_; |
@@ -857,9 +852,9 @@ |
bool IsCanonicalSignatureClass() const; |
// Check the subtype relationship. |
- bool IsSubtypeOf(const AbstractTypeArguments& type_arguments, |
+ bool IsSubtypeOf(const TypeArguments& type_arguments, |
const Class& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const { |
return TypeTest(kIsSubtypeOf, |
type_arguments, |
@@ -869,9 +864,9 @@ |
} |
// Check the 'more specific' relationship. |
- bool IsMoreSpecificThan(const AbstractTypeArguments& type_arguments, |
+ bool IsMoreSpecificThan(const TypeArguments& type_arguments, |
const Class& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const { |
return TypeTest(kIsMoreSpecificThan, |
type_arguments, |
@@ -1171,17 +1166,17 @@ |
// Check the subtype or 'more specific' relationship. |
bool TypeTest(TypeTestKind test_kind, |
- const AbstractTypeArguments& type_arguments, |
+ const TypeArguments& type_arguments, |
const Class& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const; |
static bool TypeTestNonRecursive( |
const Class& cls, |
TypeTestKind test_kind, |
- const AbstractTypeArguments& type_arguments, |
+ const TypeArguments& type_arguments, |
const Class& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error); |
FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object); |
@@ -1224,44 +1219,24 @@ |
}; |
-// AbstractTypeArguments is an abstract superclass. |
-// Subclasses of AbstractTypeArguments are TypeArguments and |
-// InstantiatedTypeArguments. |
-class AbstractTypeArguments : public Object { |
+// A TypeArguments is an array of AbstractType. |
+class TypeArguments : public Object { |
public: |
- // Returns true if all types of this vector are finalized. |
- virtual bool IsFinalized() const { return true; } |
- |
- // 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 bound_error is not NULL, it may be set to reflect a bound error. |
- virtual RawAbstractTypeArguments* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
- Error* bound_error, |
- GrowableObjectArray* trail = NULL) const; |
- |
- // Do not clone InstantiatedTypeArguments or null vectors, since they are |
- // considered finalized. |
- virtual RawAbstractTypeArguments* CloneUnfinalized() const { |
- return this->raw(); |
+ intptr_t Length() const; |
+ RawAbstractType* TypeAt(intptr_t index) const; |
+ static intptr_t type_at_offset(intptr_t index) { |
+ return OFFSET_OF(RawTypeArguments, types_) + index * kWordSize; |
} |
+ void SetTypeAt(intptr_t index, const AbstractType& value) const; |
- // Null vectors are canonical. |
- virtual RawAbstractTypeArguments* Canonicalize( |
- GrowableObjectArray* trail = NULL) const { |
- return this->raw(); |
- } |
- |
// The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>". |
- virtual RawString* Name() const { |
+ 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 { |
+ RawString* UserVisibleName() const { |
return SubvectorName(0, Length(), kUserVisibleName); |
} |
@@ -1281,7 +1256,7 @@ |
// Check the subtype relationship, considering only a subvector of length |
// 'len' starting at 'from_index'. |
- bool IsSubtypeOf(const AbstractTypeArguments& other, |
+ bool IsSubtypeOf(const TypeArguments& other, |
intptr_t from_index, |
intptr_t len, |
Error* bound_error) const { |
@@ -1290,7 +1265,7 @@ |
// Check the 'more specific' relationship, considering only a subvector of |
// length 'len' starting at 'from_index'. |
- bool IsMoreSpecificThan(const AbstractTypeArguments& other, |
+ bool IsMoreSpecificThan(const TypeArguments& other, |
intptr_t from_index, |
intptr_t len, |
Error* bound_error) const { |
@@ -1298,82 +1273,49 @@ |
} |
// Check if the vectors are equal. |
- bool Equals(const AbstractTypeArguments& other) const { |
+ bool Equals(const TypeArguments& other) const { |
return IsEquivalent(other); |
} |
- bool IsEquivalent(const AbstractTypeArguments& other, |
+ bool IsEquivalent(const TypeArguments& other, |
GrowableObjectArray* trail = NULL) 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(GrowableObjectArray* trail = NULL) const; |
- virtual bool IsUninstantiatedIdentity() const; |
- virtual bool CanShareInstantiatorTypeArguments( |
- const Class& instantiator_class) const; |
- virtual bool IsBounded() const; |
+ bool IsResolved() const; |
+ bool IsInstantiated(GrowableObjectArray* trail = NULL) const; |
+ bool IsUninstantiatedIdentity() const; |
+ bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const; |
- virtual intptr_t Hash() const; |
+ // Returns true if all types of this vector are finalized. |
+ bool IsFinalized() const; |
+ bool IsBounded() const; |
- private: |
- // Check if the subvector of length 'len' starting at 'from_index' of this |
- // type argument vector consists solely of DynamicType. |
- // 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 from_index, |
- intptr_t len) const; |
+ // Clone this type argument vector and clone all unfinalized type arguments. |
+ // Finalized type arguments are shared. |
+ RawTypeArguments* CloneUnfinalized() const; |
- // Check the subtype or 'more specific' relationship, considering only a |
- // subvector of length 'len' starting at 'from_index'. |
- bool TypeTest(TypeTestKind test_kind, |
- const AbstractTypeArguments& other, |
- intptr_t from_index, |
- intptr_t len, |
- Error* bound_error) const; |
- |
- // Return the internal or public name of a subvector of this type argument |
- // vector, e.g. "<T, dynamic, List<T>, int>". |
- RawString* SubvectorName(intptr_t from_index, |
- intptr_t len, |
- NameVisibility name_visibility) const; |
- |
- protected: |
- HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object); |
- friend class AbstractType; |
- friend class Class; |
-}; |
- |
- |
-// A TypeArguments is an array of AbstractType. |
-class TypeArguments : public AbstractTypeArguments { |
- 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(GrowableObjectArray* trail = NULL) const; |
- virtual bool IsUninstantiatedIdentity() const; |
- virtual bool CanShareInstantiatorTypeArguments( |
- const Class& instantiator_class) const; |
- virtual bool IsFinalized() const; |
- virtual bool IsBounded() const; |
- virtual RawAbstractTypeArguments* CloneUnfinalized() const; |
// Canonicalize only if instantiated, otherwise returns 'this'. |
- virtual RawAbstractTypeArguments* Canonicalize( |
- GrowableObjectArray* trail = NULL) const; |
+ RawTypeArguments* Canonicalize(GrowableObjectArray* trail = NULL) const; |
- virtual RawAbstractTypeArguments* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_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 bound_error is not NULL, it may be set to reflect a bound error. |
+ RawTypeArguments* InstantiateFrom( |
+ const TypeArguments& instantiator_type_arguments, |
Error* bound_error, |
GrowableObjectArray* trail = NULL) const; |
+ // Runtime instantiation with canonicalization. Not to be used during type |
+ // finalization at compile time. |
+ RawTypeArguments* InstantiateAndCanonicalizeFrom( |
+ const TypeArguments& instantiator_type_arguments, |
+ Error* bound_error) const; |
+ |
+ static intptr_t instantiations_offset() { |
+ return OFFSET_OF(RawTypeArguments, instantiations_); |
+ } |
+ |
static const intptr_t kBytesPerElement = kWordSize; |
static const intptr_t kMaxElements = kSmiMax / kBytesPerElement; |
@@ -1387,90 +1329,48 @@ |
} |
static intptr_t InstanceSize(intptr_t len) { |
- // Ensure that the types_ is not adding to the object length. |
- ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (1 * kWordSize))); |
+ // Ensure that the types_ is not adding to the object size, which includes |
+ // 2 fields: instantiations_ and length_. |
+ ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (2 * kWordSize))); |
ASSERT(0 <= len && len <= kMaxElements); |
return RoundedAllocationSize( |
sizeof(RawTypeArguments) + (len * kBytesPerElement)); |
} |
+ intptr_t Hash() const; |
+ |
static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld); |
private: |
- RawAbstractType** TypeAddr(intptr_t index) const; |
- void SetLength(intptr_t value) const; |
+ // Check if the subvector of length 'len' starting at 'from_index' of this |
+ // type argument vector consists solely of DynamicType. |
+ // 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 from_index, |
+ intptr_t len) const; |
- FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments); |
- friend class Class; |
-}; |
+ // Check the subtype or 'more specific' relationship, considering only a |
+ // subvector of length 'len' starting at 'from_index'. |
+ bool TypeTest(TypeTestKind test_kind, |
+ const TypeArguments& other, |
+ intptr_t from_index, |
+ intptr_t len, |
+ Error* bound_error) const; |
+ // Return the internal or public name of a subvector of this type argument |
+ // vector, e.g. "<T, dynamic, List<T>, int>". |
+ RawString* SubvectorName(intptr_t from_index, |
+ intptr_t len, |
+ NameVisibility name_visibility) const; |
-// An instance of InstantiatedTypeArguments is never encountered at compile |
-// time, but only at run time, when type parameters can be matched to actual |
-// types. |
-// An instance of InstantiatedTypeArguments consists of a pair of |
-// AbstractTypeArguments objects. The first type argument vector is |
-// uninstantiated, because it contains type expressions referring to at least |
-// one TypeParameter object, i.e. to a type that is not known at compile time. |
-// The second type argument vector is the instantiator, because each type |
-// 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(GrowableObjectArray* trail = NULL) const { |
- return true; |
- } |
- virtual bool IsUninstantiatedIdentity() const { |
- UNREACHABLE(); |
- return false; |
- } |
- virtual bool CanShareInstantiatorTypeArguments( |
- const Class& instantiator_class) const { |
- UNREACHABLE(); |
- return false; |
- } |
- virtual bool IsBounded() const { return false; } // Bounds were checked. |
- virtual RawAbstractTypeArguments* Canonicalize( |
- GrowableObjectArray* trail = NULL) const; |
+ RawArray* instantiations() const; |
+ void set_instantiations(const Array& value) const; |
+ RawAbstractType** TypeAddr(intptr_t index) const; |
+ void SetLength(intptr_t value) const; |
- 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 { |
- return raw_ptr()->instantiator_type_arguments_; |
- } |
- static intptr_t instantiator_type_arguments_offset() { |
- return OFFSET_OF(RawInstantiatedTypeArguments, |
- instantiator_type_arguments_); |
- } |
- |
- static intptr_t InstanceSize() { |
- return RoundedAllocationSize(sizeof(RawInstantiatedTypeArguments)); |
- } |
- |
- static RawInstantiatedTypeArguments* New( |
- const AbstractTypeArguments& uninstantiated_type_arguments, |
- const AbstractTypeArguments& instantiator_type_arguments); |
- |
- private: |
- void set_uninstantiated_type_arguments( |
- const AbstractTypeArguments& value) const; |
- void set_instantiator_type_arguments( |
- const AbstractTypeArguments& value) const; |
- |
- static RawInstantiatedTypeArguments* New(); |
- |
- FINAL_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, |
- AbstractTypeArguments); |
+ FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object); |
+ friend class AbstractType; |
friend class Class; |
}; |
@@ -1531,9 +1431,8 @@ |
// signature of the given function, where all generic types (e.g. '<T, R>' in |
// 'C<T, R>(T, {b: B, c: C}) => R') are instantiated using the given |
// instantiator type argument vector of a C instance (e.g. '<A, D>'). |
- RawString* InstantiatedSignatureFrom( |
- const AbstractTypeArguments& instantiator, |
- NameVisibility name_visibility) const { |
+ RawString* InstantiatedSignatureFrom(const TypeArguments& instantiator, |
+ NameVisibility name_visibility) const { |
const bool instantiate = true; |
return BuildSignature(instantiate, name_visibility, instantiator); |
} |
@@ -1852,9 +1751,9 @@ |
// Returns true if the type of this function is a subtype of the type of |
// the other function. |
- bool IsSubtypeOf(const AbstractTypeArguments& type_arguments, |
+ bool IsSubtypeOf(const TypeArguments& type_arguments, |
const Function& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const { |
return TypeTest(kIsSubtypeOf, |
type_arguments, |
@@ -1865,9 +1764,9 @@ |
// Returns true if the type of this function is more specific than the type of |
// the other function. |
- bool IsMoreSpecificThan(const AbstractTypeArguments& type_arguments, |
+ bool IsMoreSpecificThan(const TypeArguments& type_arguments, |
const Function& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const { |
return TypeTest(kIsMoreSpecificThan, |
type_arguments, |
@@ -2031,17 +1930,17 @@ |
void BuildSignatureParameters(bool instantiate, |
NameVisibility name_visibility, |
- const AbstractTypeArguments& instantiator, |
+ const TypeArguments& instantiator, |
const GrowableObjectArray& pieces) const; |
RawString* BuildSignature(bool instantiate, |
NameVisibility name_visibility, |
- const AbstractTypeArguments& instantiator) const; |
+ const TypeArguments& instantiator) const; |
// Check the subtype or 'more specific' relationship. |
bool TypeTest(TypeTestKind test_kind, |
- const AbstractTypeArguments& type_arguments, |
+ const TypeArguments& type_arguments, |
const Function& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const; |
// Checks the type of the formal parameter at the given position for |
@@ -2050,9 +1949,9 @@ |
bool TestParameterType(TypeTestKind test_kind, |
intptr_t parameter_position, |
intptr_t other_parameter_position, |
- const AbstractTypeArguments& type_arguments, |
+ const TypeArguments& type_arguments, |
const Function& other, |
- const AbstractTypeArguments& other_type_arguments, |
+ const TypeArguments& other_type_arguments, |
Error* bound_error) const; |
FINAL_HEAP_OBJECT_IMPLEMENTATION(Function, Object); |
@@ -3834,13 +3733,13 @@ |
intptr_t NumberOfChecks() const; |
void AddCheck(intptr_t class_id, |
- const AbstractTypeArguments& instance_type_arguments, |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instance_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
const Bool& test_result) const; |
void GetCheck(intptr_t ix, |
intptr_t* class_id, |
- AbstractTypeArguments* instance_type_arguments, |
- AbstractTypeArguments* instantiator_type_arguments, |
+ TypeArguments* instance_type_arguments, |
+ TypeArguments* instantiator_type_arguments, |
Bool* test_result) const; |
static RawSubtypeTestCache* New(); |
@@ -4043,12 +3942,12 @@ |
RawType* GetType() const; |
- virtual RawAbstractTypeArguments* GetTypeArguments() const; |
- virtual void SetTypeArguments(const AbstractTypeArguments& value) const; |
+ virtual RawTypeArguments* GetTypeArguments() const; |
+ virtual void SetTypeArguments(const TypeArguments& value) const; |
// Check if the type of this instance is a subtype of the given type. |
bool IsInstanceOf(const AbstractType& type, |
- const AbstractTypeArguments& type_instantiator, |
+ const TypeArguments& type_instantiator, |
Error* bound_error) const; |
// Check whether this instance is identical to the argument according to the |
@@ -4135,7 +4034,7 @@ |
virtual bool HasResolvedTypeClass() const; |
virtual RawClass* type_class() const; |
virtual RawUnresolvedClass* unresolved_class() const; |
- virtual RawAbstractTypeArguments* arguments() const; |
+ virtual RawTypeArguments* arguments() const; |
virtual intptr_t token_pos() const; |
virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const; |
virtual bool Equals(const Instance& other) const { |
@@ -4148,7 +4047,7 @@ |
// Return a new type, or return 'this' if it is already instantiated. |
// If bound_error is not NULL, it may be set to reflect a bound error. |
virtual RawAbstractType* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
Error* bound_error, |
GrowableObjectArray* trail = NULL) const; |
@@ -4247,9 +4146,9 @@ |
protected: |
HEAP_OBJECT_IMPLEMENTATION(AbstractType, Instance); |
- friend class AbstractTypeArguments; |
friend class Class; |
friend class Function; |
+ friend class TypeArguments; |
}; |
@@ -4286,14 +4185,14 @@ |
virtual RawClass* type_class() const; |
void set_type_class(const Object& value) const; |
virtual RawUnresolvedClass* unresolved_class() const; |
- virtual RawAbstractTypeArguments* arguments() const; |
- void set_arguments(const AbstractTypeArguments& value) const; |
+ virtual RawTypeArguments* arguments() const; |
+ void set_arguments(const TypeArguments& value) const; |
virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; } |
virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const; |
virtual bool IsEquivalent(const Instance& other, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
Error* malformed_error, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* CloneUnfinalized() const; |
@@ -4355,7 +4254,7 @@ |
static RawType* NewNonParameterizedType(const Class& type_class); |
static RawType* New(const Object& clazz, |
- const AbstractTypeArguments& arguments, |
+ const TypeArguments& arguments, |
intptr_t token_pos, |
Heap::Space space = Heap::kOld); |
@@ -4367,6 +4266,7 @@ |
FINAL_HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType); |
friend class Class; |
+ friend class TypeArguments; |
}; |
@@ -4397,7 +4297,7 @@ |
virtual RawClass* type_class() const { |
return AbstractType::Handle(type()).type_class(); |
} |
- virtual RawAbstractTypeArguments* arguments() const { |
+ virtual RawTypeArguments* arguments() const { |
return AbstractType::Handle(type()).arguments(); |
} |
virtual intptr_t token_pos() const { |
@@ -4407,7 +4307,7 @@ |
virtual bool IsEquivalent(const Instance& other, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
Error* bound_error, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* Canonicalize( |
@@ -4495,7 +4395,7 @@ |
virtual bool IsEquivalent(const Instance& other, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
Error* bound_error, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* CloneUnfinalized() const; |
@@ -4557,7 +4457,7 @@ |
virtual RawUnresolvedClass* unresolved_class() const { |
return AbstractType::Handle(type()).unresolved_class(); |
} |
- virtual RawAbstractTypeArguments* arguments() const { |
+ virtual RawTypeArguments* arguments() const { |
return AbstractType::Handle(type()).arguments(); |
} |
RawAbstractType* type() const { return raw_ptr()->type_; } |
@@ -4578,7 +4478,7 @@ |
virtual bool IsEquivalent(const Instance& other, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* InstantiateFrom( |
- const AbstractTypeArguments& instantiator_type_arguments, |
+ const TypeArguments& instantiator_type_arguments, |
Error* bound_error, |
GrowableObjectArray* trail = NULL) const; |
virtual RawAbstractType* CloneUnfinalized() const; |
@@ -5665,10 +5565,10 @@ |
return raw()->GetClassId() == kImmutableArrayCid; |
} |
- virtual RawAbstractTypeArguments* GetTypeArguments() const { |
+ virtual RawTypeArguments* GetTypeArguments() const { |
return raw_ptr()->type_arguments_; |
} |
- virtual void SetTypeArguments(const AbstractTypeArguments& value) const { |
+ virtual void SetTypeArguments(const TypeArguments& value) const { |
// An Array is raw or takes one type argument. However, its type argument |
// vector may be longer than 1 due to a type optimization reusing the type |
// argument vector of the instantiator. |
@@ -5823,10 +5723,10 @@ |
void Grow(intptr_t new_capacity, Heap::Space space = Heap::kNew) const; |
RawObject* RemoveLast() const; |
- virtual RawAbstractTypeArguments* GetTypeArguments() const { |
+ virtual RawTypeArguments* GetTypeArguments() const { |
return raw_ptr()->type_arguments_; |
} |
- virtual void SetTypeArguments(const AbstractTypeArguments& value) const { |
+ virtual void SetTypeArguments(const TypeArguments& value) const { |
// A GrowableObjectArray is raw or takes one type argument. However, its |
// type argument vector may be longer than 1 due to a type optimization |
// reusing the type argument vector of the instantiator. |
@@ -6321,11 +6221,11 @@ |
return static_cast<intptr_t>(kContextOffset * kWordSize); |
} |
- static RawAbstractTypeArguments* GetTypeArguments(const Instance& closure) { |
+ static RawTypeArguments* GetTypeArguments(const Instance& closure) { |
return *TypeArgumentsAddr(closure); |
} |
static void SetTypeArguments(const Instance& closure, |
- const AbstractTypeArguments& value) { |
+ const TypeArguments& value) { |
closure.StorePointer(TypeArgumentsAddr(closure), value.raw()); |
} |
static intptr_t type_arguments_offset() { |
@@ -6350,9 +6250,9 @@ |
static const int kContextOffset = 3; |
static const int kNumFields = 3; |
- static RawAbstractTypeArguments** TypeArgumentsAddr(const Instance& obj) { |
+ static RawTypeArguments** TypeArgumentsAddr(const Instance& obj) { |
ASSERT(obj.IsClosure()); |
- return reinterpret_cast<RawAbstractTypeArguments**>( |
+ return reinterpret_cast<RawTypeArguments**>( |
reinterpret_cast<intptr_t>(obj.raw_ptr()) + type_arguments_offset()); |
} |
static RawFunction** FunctionAddr(const Instance& obj) { |