Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(416)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/object.cc

Issue 8776020: Ongoing renaming of type classes: (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: '' Created 9 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/object.h ('k') | runtime/vm/parser.h » ('j') | runtime/vm/raw_object.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc (revision 1992)
+++ runtime/vm/object.cc (working copy)
@@ -54,7 +54,8 @@
RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
RawClass* Object::instantiated_type_class_ =
reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::abstract_type_arguments_class_ =
+ reinterpret_cast<RawClass*>(RAW_NULL);
RawClass* Object::type_array_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
regis 2011/12/01 22:20:16 type_arguments_class_?
srdjan 2011/12/01 22:44:08 Done.
RawClass* Object::instantiated_type_arguments_class_ =
reinterpret_cast<RawClass*>(RAW_NULL);
@@ -92,10 +93,10 @@
return kTypeParameterClass;
} else if (raw_class == instantiated_type_class()) {
return kInstantiatedTypeClass;
- } else if (raw_class == type_arguments_class()) {
+ } else if (raw_class == abstract_type_arguments_class()) {
+ return kAbstractTypeArgumentsClass;
+ } else if (raw_class == type_array_class()) {
regis 2011/12/01 22:20:16 raw_class == type_arguments_class()?
srdjan 2011/12/01 22:44:08 Yes, forgot that one.
return kTypeArgumentsClass;
- } else if (raw_class == type_array_class()) {
- return kTypeArrayClass;
} else if (raw_class == instantiated_type_arguments_class()) {
return kInstantiatedTypeArgumentsClass;
} else if (raw_class == function_class()) {
@@ -139,8 +140,8 @@
case kTypeClass: return type_class();
case kTypeParameterClass: return type_parameter_class();
case kInstantiatedTypeClass: return instantiated_type_class();
- case kTypeArgumentsClass: return type_arguments_class();
- case kTypeArrayClass: return type_array_class();
+ case kAbstractTypeArgumentsClass: return abstract_type_arguments_class();
+ case kTypeArgumentsClass: return type_array_class();
regis 2011/12/01 22:20:16 return type_arguments_class()?
srdjan 2011/12/01 22:44:08 Done.
case kInstantiatedTypeArgumentsClass:
return instantiated_type_arguments_class();
case kFunctionClass: return function_class();
@@ -173,8 +174,8 @@
case kTypeClass: return "Type";
case kTypeParameterClass: return "TypeParameter";
case kInstantiatedTypeClass: return "InstantiatedType";
+ case kAbstractTypeArgumentsClass: return "AbstractTypeArguments";
case kTypeArgumentsClass: return "TypeArguments";
- case kTypeArrayClass: return "TypeArray";
case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
case kFunctionClass: return "Function";
case kFieldClass: return "Field";
@@ -283,10 +284,10 @@
cls = Class::New<InstantiatedType>();
instantiated_type_class_ = cls.raw();
+ cls = Class::New<AbstractTypeArguments>();
+ abstract_type_arguments_class_ = cls.raw();
+
cls = Class::New<TypeArguments>();
- type_arguments_class_ = cls.raw();
-
- cls = Class::New<TypeArray>();
type_array_class_ = cls.raw();
regis 2011/12/01 22:20:16 ditto
srdjan 2011/12/01 22:44:08 Done.
cls = Class::New<InstantiatedTypeArguments>();
@@ -747,7 +748,7 @@
// matching the type parameters here.
if (num_type_params > 0) {
const Array& type_params = Array::Handle(type_parameters());
- signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
+ signature_type_arguments = TypeArguments::New(num_type_params);
String& type_param_name = String::Handle();
AbstractType& type_param = AbstractType::Handle();
for (int i = 0; i < num_type_params; i++) {
@@ -853,7 +854,7 @@
}
-void Class::set_type_parameter_extends(const TypeArray& value) const {
+void Class::set_type_parameter_extends(const TypeArguments& value) const {
StorePointer(&raw_ptr()->type_parameter_extends_, value.raw());
}
@@ -1088,7 +1089,7 @@
const Class& owner_class = Class::Handle(signature_function.owner());
ASSERT(!owner_class.IsNull());
Array& type_parameters = Array::Handle();
- TypeArray& type_parameter_extends = TypeArray::Handle();
+ TypeArguments& type_parameter_extends = TypeArguments::Handle();
// A signature class extends class Instance and is parameterized in the same
// way as the owner class of its non-static signature function.
// It is not type parameterized if its signature function is static.
@@ -1300,9 +1301,9 @@
bool Class::IsMoreSpecificThan(
- const TypeArguments& type_arguments,
+ const AbstractTypeArguments& type_arguments,
const Class& other,
- const TypeArguments& other_type_arguments) const {
+ const AbstractTypeArguments& other_type_arguments) const {
// Check for DynamicType.
// The DynamicType on the lefthand side is replaced by the bottom type, which
// is more specific than any type.
@@ -1341,7 +1342,7 @@
Array& interfaces = Array::Handle(this->interfaces());
AbstractType& interface = AbstractType::Handle();
Class& interface_class = Class::Handle();
- TypeArguments& interface_args = TypeArguments::Handle();
+ AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
for (intptr_t i = 0; i < interfaces.Length(); i++) {
interface ^= interfaces.At(i);
interface_class = interface.type_class();
@@ -1355,7 +1356,7 @@
// This type is raw, so the uninstantiated type arguments of the
// interface cannot be instantiated and we must check against a raw
// interface.
- interface_args = TypeArray::null();
+ interface_args = TypeArguments::null();
} else {
// The type arguments of this type that are referred to by the type
// parameters of the interface are at the end of the type vector,
@@ -1404,9 +1405,9 @@
bool Class::TestType(TypeTestKind test,
- const TypeArguments& type_arguments,
+ const AbstractTypeArguments& type_arguments,
const Class& other,
- const TypeArguments& other_type_arguments) const {
+ const AbstractTypeArguments& other_type_arguments) const {
ASSERT(is_finalized() || !ClassFinalizer::AllClassesFinalized());
ASSERT(other.is_finalized() || !ClassFinalizer::AllClassesFinalized());
if (test == kIsAssignableTo) {
@@ -1704,7 +1705,7 @@
}
-RawTypeArguments* AbstractType::arguments() const {
+RawAbstractTypeArguments* AbstractType::arguments() const {
// AbstractType is an abstract class.
UNREACHABLE();
return NULL;
@@ -1740,7 +1741,7 @@
RawAbstractType* AbstractType::InstantiateFrom(
- const TypeArguments& instantiator_type_arguments,
+ const AbstractTypeArguments& instantiator_type_arguments,
intptr_t offset) const {
// AbstractType is an abstract class.
UNREACHABLE();
@@ -1758,7 +1759,8 @@
RawString* AbstractType::Name() const {
// If the type is still being finalized, we may be reporting an error about
// an illformed type, so proceed with caution.
- const TypeArguments& args = TypeArguments::Handle(arguments());
+ const AbstractTypeArguments& args =
+ AbstractTypeArguments::Handle(arguments());
const intptr_t num_args = args.IsNull() ? 0 : args.Length();
String& class_name = String::Handle();
intptr_t first_type_param_index;
@@ -1897,9 +1899,10 @@
(Index() == other.Index());
}
const Class& cls = Class::Handle(type_class());
- return cls.IsMoreSpecificThan(TypeArguments::Handle(arguments()),
- Class::Handle(other.type_class()),
- TypeArguments::Handle(other.arguments()));
+ return cls.IsMoreSpecificThan(
+ AbstractTypeArguments::Handle(arguments()),
+ Class::Handle(other.type_class()),
+ AbstractTypeArguments::Handle(other.arguments()));
}
@@ -1913,14 +1916,14 @@
}
const Class& cls = Class::Handle(type_class());
if (test == kIsSubtypeOf) {
- return cls.IsSubtypeOf(TypeArguments::Handle(arguments()),
+ return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
Class::Handle(other.type_class()),
- TypeArguments::Handle(other.arguments()));
+ AbstractTypeArguments::Handle(other.arguments()));
} else {
ASSERT(test == kIsAssignableTo);
- return cls.IsAssignableTo(TypeArguments::Handle(arguments()),
+ return cls.IsAssignableTo(AbstractTypeArguments::Handle(arguments()),
Class::Handle(other.type_class()),
- TypeArguments::Handle(other.arguments()));
+ AbstractTypeArguments::Handle(other.arguments()));
}
}
@@ -1932,7 +1935,7 @@
RawAbstractType* AbstractType::NewInstantiatedType(
const AbstractType& uninstantiated_type,
- const TypeArguments& instantiator_type_arguments) {
+ const AbstractTypeArguments& instantiator_type_arguments) {
return InstantiatedType::New(uninstantiated_type,
instantiator_type_arguments);
}
@@ -2001,8 +2004,8 @@
RawType* Type::NewRawType(const Class& type_class) {
- const TypeArguments& type_arguments =
- TypeArguments::Handle(type_class.type_parameter_extends());
+ const AbstractTypeArguments& type_arguments =
+ AbstractTypeArguments::Handle(type_class.type_parameter_extends());
return NewParameterizedType(Object::Handle(type_class.raw()), type_arguments);
}
@@ -2021,7 +2024,7 @@
RawType* Type::NewParameterizedType(const Object& clazz,
- const TypeArguments& arguments) {
+ const AbstractTypeArguments& arguments) {
return Type::New(clazz, arguments);
}
@@ -2045,7 +2048,8 @@
if (!HasResolvedTypeClass()) {
return false;
}
- const TypeArguments& args = TypeArguments::Handle(arguments());
+ const AbstractTypeArguments& args =
+ AbstractTypeArguments::Handle(arguments());
return args.IsNull() || args.IsResolved();
}
@@ -2073,23 +2077,25 @@
}
-RawTypeArguments* Type::arguments() const {
+RawAbstractTypeArguments* Type::arguments() const {
return raw_ptr()->arguments_;
}
bool Type::IsInstantiated() const {
- const TypeArguments& args = TypeArguments::Handle(arguments());
+ const AbstractTypeArguments& args =
+ AbstractTypeArguments::Handle(arguments());
return args.IsNull() || args.IsInstantiated();
}
RawAbstractType* Type::InstantiateFrom(
- const TypeArguments& instantiator_type_arguments,
+ const AbstractTypeArguments& instantiator_type_arguments,
intptr_t offset) const {
ASSERT(IsFinalized());
ASSERT(!IsInstantiated());
- TypeArguments& type_arguments = TypeArguments::Handle(arguments());
+ AbstractTypeArguments& type_arguments =
+ AbstractTypeArguments::Handle(arguments());
type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
offset);
const Class& cls = Class::Handle(type_class());
@@ -2115,8 +2121,9 @@
if (type_class() != other_parameterized_type.type_class()) {
return false;
}
- return TypeArguments::AreEqual(TypeArguments::Handle(arguments()),
- TypeArguments::Handle(other.arguments()));
+ return AbstractTypeArguments::AreEqual(
+ AbstractTypeArguments::Handle(arguments()),
+ AbstractTypeArguments::Handle(other.arguments()));
}
@@ -2172,7 +2179,7 @@
}
-void Type::set_arguments(const TypeArguments& value) const {
+void Type::set_arguments(const AbstractTypeArguments& value) const {
StorePointer(&raw_ptr()->arguments_, value.raw());
}
@@ -2187,7 +2194,7 @@
RawType* Type::New(const Object& clazz,
- const TypeArguments& arguments) {
+ const AbstractTypeArguments& arguments) {
const Type& result = Type::Handle(Type::New());
result.set_type_class(clazz);
result.set_arguments(arguments);
@@ -2206,7 +2213,8 @@
const char* Type::ToCString() const {
if (IsResolved()) {
- const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
+ const AbstractTypeArguments& type_arguments =
+ AbstractTypeArguments::Handle(arguments());
if (type_arguments.IsNull()) {
const char* format = "Type: class '%s'";
const char* class_name =
@@ -2220,7 +2228,8 @@
const char* format = "Type: class '%s', args:[%s]";
const char* class_name =
String::Handle(Class::Handle(type_class()).Name()).ToCString();
- const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
+ const char* args_cstr =
+ AbstractTypeArguments::Handle(arguments()).ToCString();
intptr_t len = OS::SNPrint(NULL, 0, format, class_name, args_cstr) + 1;
char* chars = reinterpret_cast<char*>(
Isolate::Current()->current_zone()->Allocate(len));
@@ -2259,7 +2268,7 @@
RawAbstractType* TypeParameter::InstantiateFrom(
- const TypeArguments& instantiator_type_arguments,
+ const AbstractTypeArguments& instantiator_type_arguments,
intptr_t offset) const {
if (instantiator_type_arguments.IsNull()) {
return Type::DynamicType();
@@ -2302,11 +2311,11 @@
}
-RawTypeArguments* InstantiatedType::arguments() const {
- return TypeArguments::NewInstantiatedTypeArguments(
- TypeArguments::Handle(AbstractType::Handle(
+RawAbstractTypeArguments* InstantiatedType::arguments() const {
+ return AbstractTypeArguments::NewInstantiatedTypeArguments(
+ AbstractTypeArguments::Handle(AbstractType::Handle(
uninstantiated_type()).arguments()),
- TypeArguments::Handle(instantiator_type_arguments()));
+ AbstractTypeArguments::Handle(instantiator_type_arguments()));
}
@@ -2317,7 +2326,7 @@
void InstantiatedType::set_instantiator_type_arguments(
- const TypeArguments& value) const {
+ const AbstractTypeArguments& value) const {
StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
}
@@ -2334,7 +2343,7 @@
RawInstantiatedType* InstantiatedType::New(
const AbstractType& uninstantiated_type,
- const TypeArguments& instantiator_type_arguments) {
+ const AbstractTypeArguments& instantiator_type_arguments) {
const InstantiatedType& result =
InstantiatedType::Handle(InstantiatedType::New());
result.set_uninstantiated_type(uninstantiated_type);
@@ -2348,56 +2357,58 @@
}
-intptr_t TypeArguments::Length() const {
- // TypeArguments is an abstract class.
+intptr_t AbstractTypeArguments::Length() const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return -1;
}
-RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
- // TypeArguments is an abstract class.
+RawAbstractType* AbstractTypeArguments::TypeAt(intptr_t index) const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return NULL;
}
-void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
- // TypeArguments is an abstract class.
+void AbstractTypeArguments::SetTypeAt(intptr_t index,
+ const AbstractType& value) const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
}
-bool TypeArguments::IsResolved() const {
- // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsResolved() const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return false;
}
-bool TypeArguments::IsInstantiated() const {
- // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsInstantiated() const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return false;
}
-bool TypeArguments::IsUninstantiatedIdentity() const {
- // TypeArguments is an abstract class.
+bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return false;
}
-bool TypeArguments::Equals(const TypeArguments& other) const {
- // TypeArguments is an abstract class.
+bool AbstractTypeArguments::Equals(const AbstractTypeArguments& other) const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return false;
}
-bool TypeArguments::AreEqual(const TypeArguments& arguments,
- const TypeArguments& other_arguments) {
+bool AbstractTypeArguments::AreEqual(
+ const AbstractTypeArguments& arguments,
+ const AbstractTypeArguments& other_arguments) {
if (arguments.raw() == other_arguments.raw()) {
return true;
}
@@ -2411,16 +2422,16 @@
}
-RawTypeArguments* TypeArguments::InstantiateFrom(
- const TypeArguments& instantiator_type_arguments,
+RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
+ const AbstractTypeArguments& instantiator_type_arguments,
intptr_t offset) const {
- // TypeArguments is an abstract class.
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
return NULL;
}
-bool TypeArguments::IsDynamicTypes(intptr_t len) const {
+bool AbstractTypeArguments::IsDynamicTypes(intptr_t len) const {
ASSERT(Length() >= len);
AbstractType& type = AbstractType::Handle();
Class& type_class = Class::Handle();
@@ -2440,8 +2451,9 @@
}
-bool TypeArguments::IsMoreSpecificThan(const TypeArguments& other,
- intptr_t len) const {
+bool AbstractTypeArguments::IsMoreSpecificThan(
+ const AbstractTypeArguments& other,
+ intptr_t len) const {
ASSERT(Length() >= len);
ASSERT(!other.IsNull());
ASSERT(other.Length() >= len);
@@ -2460,44 +2472,39 @@
}
-RawTypeArguments* TypeArguments::NewTypeArray(intptr_t len) {
- return TypeArray::New(len);
-}
-
-
-RawTypeArguments* TypeArguments::NewInstantiatedTypeArguments(
- const TypeArguments& uninstantiated_type_arguments,
- const TypeArguments& instantiator_type_arguments) {
+RawAbstractTypeArguments* AbstractTypeArguments::NewInstantiatedTypeArguments(
+ const AbstractTypeArguments& uninstantiated_type_arguments,
+ const AbstractTypeArguments& instantiator_type_arguments) {
return InstantiatedTypeArguments::New(uninstantiated_type_arguments,
instantiator_type_arguments);
}
-const char* TypeArguments::ToCString() const {
- // TypeArguments is an abstract class.
+const char* AbstractTypeArguments::ToCString() const {
+ // AbstractTypeArguments is an abstract class.
UNREACHABLE();
- return "TypeArguments";
+ return "AbstractTypeArguments";
}
-intptr_t TypeArray::Length() const {
+intptr_t TypeArguments::Length() const {
ASSERT(!IsNull());
return Smi::Value(raw_ptr()->length_);
}
-RawAbstractType* TypeArray::TypeAt(intptr_t index) const {
+RawAbstractType* TypeArguments::TypeAt(intptr_t index) const {
return *TypeAddr(index);
}
-void TypeArray::SetTypeAt(intptr_t index, const AbstractType& value) const {
+void TypeArguments::SetTypeAt(intptr_t index, const AbstractType& value) const {
// TODO(iposva): Add storing NoGCScope.
*TypeAddr(index) = value.raw();
}
-bool TypeArray::IsResolved() const {
+bool TypeArguments::IsResolved() const {
AbstractType& type = AbstractType::Handle();
intptr_t num_types = Length();
for (intptr_t i = 0; i < num_types; i++) {
@@ -2510,7 +2517,7 @@
}
-bool TypeArray::IsInstantiated() const {
+bool TypeArguments::IsInstantiated() const {
AbstractType& type = AbstractType::Handle();
intptr_t num_types = Length();
for (intptr_t i = 0; i < num_types; i++) {
@@ -2523,7 +2530,7 @@
}
-bool TypeArray::IsUninstantiatedIdentity() const {
+bool TypeArguments::IsUninstantiatedIdentity() const {
ASSERT(!IsInstantiated());
AbstractType& type = AbstractType::Handle();
intptr_t num_types = Length();
@@ -2537,7 +2544,7 @@
}
-bool TypeArray::Equals(const TypeArguments& other) const {
+bool TypeArguments::Equals(const AbstractTypeArguments& other) const {
intptr_t num_types = Length();
if (num_types != other.Length()) {
return false;
@@ -2555,8 +2562,8 @@
}
-RawTypeArguments* TypeArray::InstantiateFrom(
- const TypeArguments& instantiator_type_arguments,
+RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
+ const AbstractTypeArguments& instantiator_type_arguments,
intptr_t offset) const {
ASSERT(!IsInstantiated());
if ((offset == 0) &&
@@ -2566,7 +2573,8 @@
return instantiator_type_arguments.raw();
}
const intptr_t num_types = Length();
- TypeArray& instantiated_array = TypeArray::Handle(TypeArray::New(num_types));
+ TypeArguments& instantiated_array =
+ TypeArguments::Handle(TypeArguments::New(num_types));
AbstractType& type = AbstractType::Handle();
for (intptr_t i = 0; i < num_types; i++) {
type = TypeAt(i);
@@ -2579,7 +2587,7 @@
}
-RawTypeArray* TypeArray::New(intptr_t len) {
+RawTypeArguments* TypeArguments::New(intptr_t len) {
if ((len < 0) || (len > kMaxTypes)) {
// TODO(iposva): Should we throw an illegal parameter exception?
UNIMPLEMENTED();
@@ -2587,10 +2595,10 @@
}
const Class& type_array_class = Class::Handle(Object::type_array_class());
regis 2011/12/01 22:20:16 ditto
- TypeArray& result = TypeArray::Handle();
+ TypeArguments& result = TypeArguments::Handle();
{
RawObject* raw = Object::Allocate(type_array_class,
regis 2011/12/01 22:20:16 ditto
- TypeArray::InstanceSize(len),
+ TypeArguments::InstanceSize(len),
Heap::kOld);
NoGCScope no_gc;
result ^= raw;
@@ -2603,26 +2611,26 @@
}
-RawAbstractType** TypeArray::TypeAddr(intptr_t index) const {
+RawAbstractType** TypeArguments::TypeAddr(intptr_t index) const {
// TODO(iposva): Determine if we should throw an exception here.
ASSERT((index >= 0) && (index < Length()));
return &raw_ptr()->types_[index];
}
-void TypeArray::SetLength(intptr_t value) {
+void TypeArguments::SetLength(intptr_t value) {
// This is only safe because we create a new Smi, which does not cause
// heap allocation.
raw_ptr()->length_ = Smi::New(value);
}
-const char* TypeArray::ToCString() const {
+const char* TypeArguments::ToCString() const {
if (IsNull()) {
- return "NULL TypeArray";
+ return "NULL TypeArguments";
}
const char* format = "%s [%s]";
- const char* prev_cstr = "TypeArray:";
+ const char* prev_cstr = "TypeArguments:";
for (int i = 0; i < Length(); i++) {
const char* type_cstr = AbstractType::Handle(TypeAt(i)).ToCString();
intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
@@ -2636,21 +2644,23 @@
intptr_t InstantiatedTypeArguments::Length() const {
- return TypeArguments::Handle(uninstantiated_type_arguments()).Length();
+ return AbstractTypeArguments::Handle(
+ uninstantiated_type_arguments()).Length();
}
RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
const AbstractType& type = AbstractType::Handle(
- TypeArguments::Handle(uninstantiated_type_arguments()).TypeAt(index));
+ AbstractTypeArguments::Handle(
+ uninstantiated_type_arguments()).TypeAt(index));
if (type.IsTypeParameter()) {
- TypeArguments& instantiator =
- TypeArguments::Handle(instantiator_type_arguments());
+ AbstractTypeArguments& instantiator =
+ AbstractTypeArguments::Handle(instantiator_type_arguments());
return instantiator.TypeAt(type.Index());
}
if (!type.IsInstantiated()) {
return InstantiatedType::New(
- type, TypeArguments::Handle(instantiator_type_arguments()));
+ type, AbstractTypeArguments::Handle(instantiator_type_arguments()));
}
return type.raw();
}
@@ -2665,13 +2675,13 @@
void InstantiatedTypeArguments::set_uninstantiated_type_arguments(
- const TypeArguments& value) const {
+ const AbstractTypeArguments& value) const {
StorePointer(&raw_ptr()->uninstantiated_type_arguments_, value.raw());
}
void InstantiatedTypeArguments::set_instantiator_type_arguments(
- const TypeArguments& value) const {
+ const AbstractTypeArguments& value) const {
StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
}
@@ -2687,8 +2697,8 @@
RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
- const TypeArguments& uninstantiated_type_arguments,
- const TypeArguments& instantiator_type_arguments) {
+ const AbstractTypeArguments& uninstantiated_type_arguments,
+ const AbstractTypeArguments& instantiator_type_arguments) {
const InstantiatedTypeArguments& result =
InstantiatedTypeArguments::Handle(InstantiatedTypeArguments::New());
result.set_uninstantiated_type_arguments(uninstantiated_type_arguments);
@@ -2703,9 +2713,10 @@
}
const char* format = "InstantiatedTypeArguments: [%s] instantiator: [%s]\n";
const char* arg_cstr =
- TypeArguments::Handle(uninstantiated_type_arguments()).ToCString();
+ AbstractTypeArguments::Handle(
+ uninstantiated_type_arguments()).ToCString();
const char* instantiator_cstr =
- TypeArguments::Handle(instantiator_type_arguments()).ToCString();
+ AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
intptr_t len =
OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
char* chars = reinterpret_cast<char*>(
@@ -2997,9 +3008,9 @@
bool Function::TestParameterType(
intptr_t parameter_position,
- const TypeArguments& type_arguments,
+ const AbstractTypeArguments& type_arguments,
const Function& other,
- const TypeArguments& other_type_arguments) const {
+ const AbstractTypeArguments& other_type_arguments) const {
AbstractType& param_type =
AbstractType::Handle(ParameterTypeAt(parameter_position));
if (!param_type.IsInstantiated()) {
@@ -3025,10 +3036,11 @@
}
-bool Function::TestType(TypeTestKind test,
- const TypeArguments& type_arguments,
- const Function& other,
- const TypeArguments& other_type_arguments) const {
+bool Function::TestType(
+ TypeTestKind test,
+ const AbstractTypeArguments& type_arguments,
+ const Function& other,
+ const AbstractTypeArguments& other_type_arguments) const {
const intptr_t num_fixed_params = num_fixed_parameters();
const intptr_t num_opt_params = num_optional_parameters();
const intptr_t other_num_fixed_params = other.num_fixed_parameters();
@@ -3247,7 +3259,7 @@
RawString* Function::BuildSignature(bool instantiate,
- const TypeArguments& instantiator,
+ const AbstractTypeArguments& instantiator,
intptr_t offset) const {
GrowableArray<const String*> pieces;
const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
@@ -3268,7 +3280,7 @@
if (!type_parameters.IsNull()) {
intptr_t num_type_parameters = type_parameters.Length();
pieces.Add(&kLAngleBracket);
- const TypeArray& type_parameter_extends = TypeArray::Handle(
+ const TypeArguments& type_parameter_extends = TypeArguments::Handle(
function_class.type_parameter_extends());
AbstractType& parameter_extends = AbstractType::Handle();
for (intptr_t i = 0; i < num_type_parameters; i++) {
@@ -5000,7 +5012,7 @@
return Type::NullType();
}
const Class& cls = Class::Handle(clazz());
- TypeArguments& type_arguments = TypeArguments::Handle();
+ AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
if (cls.HasTypeArguments()) {
type_arguments = GetTypeArguments();
}
@@ -5010,17 +5022,17 @@
}
-RawTypeArguments* Instance::GetTypeArguments() const {
+RawAbstractTypeArguments* Instance::GetTypeArguments() const {
const Class& cls = Class::Handle(clazz());
intptr_t field_offset = cls.type_arguments_instance_field_offset();
ASSERT(field_offset != Class::kNoTypeArguments);
- TypeArguments& type_arguments = TypeArguments::Handle();
+ AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
type_arguments ^= *FieldAddrAtOffset(field_offset);
return type_arguments.raw();
}
-void Instance::SetTypeArguments(const TypeArguments& value) const {
+void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
const Class& cls = Class::Handle(clazz());
intptr_t field_offset = cls.type_arguments_instance_field_offset();
ASSERT(field_offset != Class::kNoTypeArguments);
@@ -5030,7 +5042,7 @@
bool Instance::TestType(TypeTestKind test,
const AbstractType& other,
- const TypeArguments& other_instantiator) const {
+ const AbstractTypeArguments& other_instantiator) const {
ASSERT(other.IsFinalized());
ASSERT(!other.IsDynamicType());
ASSERT(!other.IsVoidType());
@@ -5055,7 +5067,7 @@
}
}
const Class& cls = Class::Handle(clazz());
- TypeArguments& type_arguments = TypeArguments::Handle();
+ AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
const intptr_t num_type_arguments = cls.NumTypeArguments();
if (num_type_arguments > 0) {
type_arguments = GetTypeArguments();
@@ -5071,7 +5083,7 @@
(type_arguments.Length() > num_type_arguments)));
}
Class& other_class = Class::Handle();
- TypeArguments& other_type_arguments = TypeArguments::Handle();
+ AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
// In case 'other' is not instantiated, we could simply call
// other.InstantiateFrom(other_instantiator, 0), however, we can save the
// allocation of a new AbstractType by inlining the code.
@@ -5145,7 +5157,7 @@
} else {
const char* kFormat = "Instance of '%s'";
Class& cls = Class::Handle(clazz());
- TypeArguments& type_arguments = TypeArguments::Handle();
+ AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
const intptr_t num_type_arguments = cls.NumTypeArguments();
if (num_type_arguments > 0) {
type_arguments = GetTypeArguments();
@@ -6833,9 +6845,9 @@
}
// Must have the same type arguments.
- if (!TypeArguments::AreEqual(
- TypeArguments::Handle(GetTypeArguments()),
- TypeArguments::Handle(other.GetTypeArguments()))) {
+ if (!AbstractTypeArguments::AreEqual(
+ AbstractTypeArguments::Handle(GetTypeArguments()),
+ AbstractTypeArguments::Handle(other.GetTypeArguments()))) {
return false;
}
« no previous file with comments | « runtime/vm/object.h ('k') | runtime/vm/parser.h » ('j') | runtime/vm/raw_object.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698