#include <object.h>

Inheritance diagram for dart::AbstractType:

Public Member Functions
bool	IsFinalized () const

void	SetIsFinalized () const

Nullability	nullability () const

bool	IsNullable () const

bool	IsNonNullable () const

bool	IsStrictlyNonNullable () const

virtual AbstractTypePtr	SetInstantiatedNullability (const TypeParameter &type_param, Heap::Space space) const

virtual AbstractTypePtr	NormalizeFutureOrType (Heap::Space space) const

virtual bool	HasTypeClass () const

virtual classid_t	type_class_id () const

virtual ClassPtr	type_class () const

virtual TypeArgumentsPtr	arguments () const

virtual bool	IsInstantiated (Genericity genericity=kAny, intptr_t num_free_fun_type_params=kAllFree) const

virtual bool	CanonicalizeEquals (const Instance &other) const

virtual uint32_t	CanonicalizeHash () const

virtual bool	Equals (const Instance &other) const

virtual bool	IsEquivalent (const Instance &other, TypeEquality kind, FunctionTypeMapping *function_type_equivalence=nullptr) const

virtual AbstractTypePtr	InstantiateFrom (const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, intptr_t num_free_fun_type_params, Heap::Space space, FunctionTypeMapping *function_type_mapping=nullptr, intptr_t num_parent_type_args_adjustment=0) const

virtual AbstractTypePtr	UpdateFunctionTypes (intptr_t num_parent_type_args_adjustment, intptr_t num_free_fun_type_params, Heap::Space space, FunctionTypeMapping *function_type_mapping) const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

virtual AbstractTypePtr	Canonicalize (Thread *thread) const

virtual const char *	NullabilitySuffix (NameVisibility name_visibility) const

StringPtr	Name () const

const char *	NameCString () const

StringPtr	UserVisibleName () const

const char *	UserVisibleNameCString () const

StringPtr	ScrubbedName () const

const char *	ScrubbedNameCString () const

virtual void	PrintName (NameVisibility visibility, BaseTextBuffer *printer) const

virtual void	EnumerateURIs (URIs *uris) const

uword	Hash () const

virtual uword	ComputeHash () const

StringPtr	ClassName () const

bool	IsDynamicType () const

bool	IsVoidType () const

bool	IsNullType () const

bool	IsNeverType () const

bool	IsSentinelType () const

bool	IsObjectType () const

bool	IsNullableObjectType () const

bool	IsTopTypeForSubtyping () const

bool	IsTopTypeForInstanceOf () const

bool	IsBoolType () const

bool	IsIntType () const

bool	IsIntegerImplementationType () const

bool	IsDoubleType () const

bool	IsFloat32x4Type () const

bool	IsFloat64x2Type () const

bool	IsInt32x4Type () const

bool	IsNumberType () const

bool	IsSmiType () const

bool	IsMintType () const

bool	IsStringType () const

bool	IsDartFunctionType () const

bool	IsDartClosureType () const

bool	IsDartRecordType () const

bool	IsFfiPointerType () const

bool	IsFutureOrType () const

AbstractTypePtr	UnwrapFutureOr () const

bool	IsCatchAllType () const

bool	IsTypeClassAllowedBySpawnUri () const

bool	IsSubtypeOf (const AbstractType &other, Heap::Space space, FunctionTypeMapping *function_type_equivalence=nullptr) const

uword	type_test_stub_entry_point () const

CodePtr	type_test_stub () const

void	SetTypeTestingStub (const Code &stub) const

void	InitializeTypeTestingStubNonAtomic (const Code &stub) const

void	UpdateTypeTestingStubEntryPoint () const

Public Member Functions inherited from dart::Instance
virtual bool	OperatorEquals (const Instance &other) const

bool	IsIdenticalTo (const Instance &other) const

virtual bool	CanonicalizeEquals (const Instance &other) const

virtual uint32_t	CanonicalizeHash () const

intptr_t	SizeFromClass () const

InstancePtr	Canonicalize (Thread *thread) const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

virtual void	CanonicalizeFieldsLocked (Thread *thread) const

InstancePtr	CopyShallowToOldSpace (Thread *thread) const

ObjectPtr	GetField (const Field &field) const

void	SetField (const Field &field, const Object &value) const

AbstractTypePtr	GetType (Heap::Space space) const

virtual TypeArgumentsPtr	GetTypeArguments () const

virtual void	SetTypeArguments (const TypeArguments &value) const

bool	IsInstanceOf (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsValidNativeIndex (int index) const

intptr_t *	NativeFieldsDataAddr () const

intptr_t	GetNativeField (int index) const

void	GetNativeFields (uint16_t num_fields, intptr_t *field_values) const

void	SetNativeFields (uint16_t num_fields, const intptr_t *field_values) const

uint16_t	NumNativeFields () const

void	SetNativeField (int index, intptr_t value) const

bool	IsCallable (Function *function) const

ObjectPtr	Invoke (const String &selector, const Array &arguments, const Array &argument_names, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeGetter (const String &selector, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeSetter (const String &selector, const Instance &argument, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	EvaluateCompiledExpression (const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &arguments, const TypeArguments &type_arguments) const

virtual ObjectPtr	HashCode () const

IntegerPtr	IdentityHashCode (Thread *thread) const

virtual bool	IsPointer () const

Public Member Functions inherited from dart::Object
virtual	~Object ()

ObjectPtr	ptr () const

void	operator= (ObjectPtr value)

bool	IsCanonical () const

void	SetCanonical () const

void	ClearCanonical () const

bool	IsImmutable () const

void	SetImmutable () const

void	ClearImmutable () const

intptr_t	GetClassId () const

ClassPtr	clazz () const

	CLASS_LIST_FOR_HANDLES (DEFINE_CLASS_TESTER)

bool	IsNull () const

virtual const char *	ToCString () const

void	PrintJSON (JSONStream *stream, bool ref=true) const

virtual void	PrintJSONImpl (JSONStream *stream, bool ref) const

void	PrintImplementationFields (JSONStream *stream) const

virtual void	PrintImplementationFieldsImpl (const JSONArray &jsarr_fields) const

virtual const char *	JSONType () const

virtual StringPtr	DictionaryName () const

bool	IsNew () const

bool	IsOld () const

bool	InVMIsolateHeap () const

void	Print () const

Static Public Member Functions
static intptr_t	flags_offset ()

static intptr_t	hash_offset ()

static void	AddURI (URIs *uris, const String &name, const String &uri)

static StringPtr	PrintURIs (URIs *uris)

static bool	InstantiateAndTestSubtype (AbstractType subtype, AbstractType supertype, const TypeArguments &instantiator_type_args, const TypeArguments &function_type_args)

static intptr_t	type_test_stub_entry_point_offset ()

static intptr_t	InstanceSize ()

static intptr_t	NextFieldOffset ()

Static Public Member Functions inherited from dart::Instance
static bool	NullIsAssignableTo (const AbstractType &other)

static bool	NullIsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments)

static ObjectPtr	EvaluateCompiledExpression (Thread *thread, const Object &receiver, const Library &library, const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &param_values, const TypeArguments &type_param_values)

static intptr_t	UnroundedSize ()

static intptr_t	InstanceSize ()

static InstancePtr	New (const Class &cls, Heap::Space space=Heap::kNew)

static InstancePtr	NewAlreadyFinalized (const Class &cls, Heap::Space space=Heap::kNew)

static intptr_t	DataOffsetFor (intptr_t cid)

static intptr_t	ElementSizeFor (intptr_t cid)

static intptr_t	NextFieldOffset ()

static intptr_t	NativeFieldsOffset ()

Static Public Member Functions inherited from dart::Object
static ObjectPtr	RawCast (ObjectPtr obj)

static constexpr bool	ContainsCompressedPointers ()

static intptr_t	tags_offset ()

static Object &	Handle ()

static Object &	Handle (Zone *zone)

static Object &	Handle (ObjectPtr ptr)

static Object &	Handle (Zone *zone, ObjectPtr ptr)

static Object &	ZoneHandle ()

static Object &	ZoneHandle (Zone *zone)

static Object &	ZoneHandle (ObjectPtr ptr)

static Object &	ZoneHandle (Zone *zone, ObjectPtr ptr)

static Object *	ReadOnlyHandle ()

static ObjectPtr	null ()

static void	set_vm_isolate_snapshot_object_table (const Array &table)

static ClassPtr	class_class ()

static ClassPtr	dynamic_class ()

static ClassPtr	void_class ()

static ClassPtr	type_parameters_class ()

static ClassPtr	type_arguments_class ()

static ClassPtr	patch_class_class ()

static ClassPtr	function_class ()

static ClassPtr	closure_data_class ()

static ClassPtr	ffi_trampoline_data_class ()

static ClassPtr	field_class ()

static ClassPtr	script_class ()

static ClassPtr	library_class ()

static ClassPtr	namespace_class ()

static ClassPtr	kernel_program_info_class ()

static ClassPtr	code_class ()

static ClassPtr	instructions_class ()

static ClassPtr	instructions_section_class ()

static ClassPtr	instructions_table_class ()

static ClassPtr	object_pool_class ()

static ClassPtr	pc_descriptors_class ()

static ClassPtr	code_source_map_class ()

static ClassPtr	compressed_stackmaps_class ()

static ClassPtr	var_descriptors_class ()

static ClassPtr	exception_handlers_class ()

static ClassPtr	context_class ()

static ClassPtr	context_scope_class ()

static ClassPtr	sentinel_class ()

static ClassPtr	api_error_class ()

static ClassPtr	language_error_class ()

static ClassPtr	unhandled_exception_class ()

static ClassPtr	unwind_error_class ()

static ClassPtr	singletargetcache_class ()

static ClassPtr	unlinkedcall_class ()

static ClassPtr	monomorphicsmiablecall_class ()

static ClassPtr	icdata_class ()

static ClassPtr	megamorphic_cache_class ()

static ClassPtr	subtypetestcache_class ()

static ClassPtr	loadingunit_class ()

static ClassPtr	weak_serialization_reference_class ()

static ClassPtr	weak_array_class ()

static void	InitNullAndBool (IsolateGroup *isolate_group)

static void	Init (IsolateGroup *isolate_group)

static void	InitVtables ()

static void	FinishInit (IsolateGroup *isolate_group)

static void	FinalizeVMIsolate (IsolateGroup *isolate_group)

static void	FinalizeReadOnlyObject (ObjectPtr object)

static void	Cleanup ()

static ErrorPtr	Init (IsolateGroup isolate_group, const uint8_t kernel_buffer, intptr_t kernel_buffer_size)

static void	MakeUnusedSpaceTraversable (const Object &obj, intptr_t original_size, intptr_t used_size)

static intptr_t	InstanceSize ()

template<class FakeObject >
static void	VerifyBuiltinVtable (intptr_t cid)

static void	VerifyBuiltinVtables ()

static bool	ShouldHaveImmutabilityBitSet (classid_t class_id)

Protected Member Functions
bool	IsNullabilityEquivalent (Thread *thread, const AbstractType &other_type, TypeEquality kind) const

void	SetHash (intptr_t value) const

UntaggedAbstractType::TypeState	type_state () const

void	set_flags (uint32_t value) const

void	set_type_state (UntaggedAbstractType::TypeState value) const

void	set_nullability (Nullability value) const

	HEAP_OBJECT_IMPLEMENTATION (AbstractType, Instance)

Protected Member Functions inherited from dart::Instance
virtual void	PrintSharedInstanceJSON (JSONObject *jsobj, bool ref, bool include_id=true) const

Protected Member Functions inherited from dart::Object
	Object ()

uword	raw_value () const

void	setPtr (ObjectPtr value, intptr_t default_cid)

void	CheckHandle () const

cpp_vtable	vtable () const

void	set_vtable (cpp_vtable value)

bool	Contains (uword addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
type	LoadPointer (type const *addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
void	StorePointer (type const *addr, type value) const

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
void	StoreCompressedPointer (compressed_type const *addr, type value) const

template<typename type >
void	StorePointerUnaligned (type const addr, type value, Thread thread) const

void	StoreSmi (SmiPtr const *addr, SmiPtr value) const

template<typename FieldType >
void	StoreSimd128 (const FieldType *addr, simd128_value_t value) const

template<typename FieldType >
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , std::memory_order order>
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , typename ValueType >
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType , typename ValueType , std::memory_order order>
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType >
FieldType *	UnsafeMutableNonPointer (const FieldType *addr) const

	CLASS_LIST (STORE_NON_POINTER_ILLEGAL_TYPE)

void	UnimplementedMethod () const

void	AddCommonObjectProperties (JSONObject jsobj, const char protocol_type, bool ref) const

Friends
class	Class

class	ClearTypeHashVisitor

class	Function

class	TypeArguments

Additional Inherited Members
Public Types inherited from dart::Object
enum	NameVisibility { kInternalName = 0 , kScrubbedName , kUserVisibleName }

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Static Public Attributes inherited from dart::Object
static constexpr intptr_t	kHashBits = 30

static const ClassId	kClassId = kObjectCid

Static Protected Member Functions inherited from dart::Object
static DART_NOINLINE Object &	HandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object &	ZoneHandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object *	ReadOnlyHandleImpl (intptr_t cid)

static ObjectPtr	Allocate (intptr_t cls_id, intptr_t size, Heap::Space space, bool compressed, uword ptr_field_start_offset, uword ptr_field_end_offset)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space, intptr_t elements)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space, intptr_t elements)

static constexpr intptr_t	RoundedAllocationSize (intptr_t size)

static ObjectPtr	Clone (const Object &orig, Heap::Space space, bool load_with_relaxed_atomics=false)

template<typename T >
static DART_FORCE_INLINE uword	from_offset ()

template<typename T >
static DART_FORCE_INLINE uword	to_offset (intptr_t length=0)

Protected Attributes inherited from dart::Object
ObjectPtr	ptr_

Detailed Description

Definition at line 9044 of file object.h.

Member Function Documentation

◆ AddURI()

void dart::AbstractType::AddURI	(	URIs *	uris,
		const String &	name,
		const String &	uri
	)

static

Definition at line 21257 of file object.cc.

                                                                           {
  ASSERT(uris != nullptr);
  const intptr_t len = uris->length();
  ASSERT((len % 3) == 0);
  bool print_uri = false;
  for (intptr_t i = 0; i < len; i += 3) {
    if (uris->At(i).Equals(name)) {
      if (uris->At(i + 1).Equals(uri)) {
        // Same name and same URI: no need to add this already listed URI.
        return;  // No state change is possible.
      } else {
        // Same name and different URI: the name is ambiguous, print both URIs.
        print_uri = true;
        uris->SetAt(i + 2, Symbols::print());
      }
    }
  }
  uris->Add(name);
  uris->Add(uri);
  if (print_uri) {
    uris->Add(Symbols::print());
  } else {
    uris->Add(Symbols::Empty());
  }
}

◆ arguments()

TypeArgumentsPtr dart::AbstractType::arguments ( ) const

virtual

Reimplemented in dart::Type.

Definition at line 21051 of file object.cc.

                                               {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return nullptr;
}

◆ Canonicalize()

AbstractTypePtr dart::AbstractType::Canonicalize ( Thread * thread ) const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21240 of file object.cc.

                                                               {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return nullptr;
}

◆ CanonicalizeEquals()

virtual bool dart::AbstractType::CanonicalizeEquals ( const Instance & other ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 9090 of file object.h.

                                                               {
    return Equals(other);
  }

◆ CanonicalizeHash()

virtual uint32_t dart::AbstractType::CanonicalizeHash ( ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 9093 of file object.h.

9093{ return Hash(); }

dart::AbstractType::Hash

uword Hash() const

Definition: object.h:13377

◆ CanonicalizeLocked()

virtual InstancePtr dart::AbstractType::CanonicalizeLocked ( Thread * thread ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 9138 of file object.h.

                                                               {
    return Canonicalize(thread);
  }

◆ ClassName()

StringPtr dart::AbstractType::ClassName ( ) const

Definition at line 21362 of file object.cc.

                                        {
  ASSERT(!IsFunctionType() && !IsRecordType());
  return Class::Handle(type_class()).Name();
}

◆ ComputeHash()

uword dart::AbstractType::ComputeHash ( ) const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21748 of file object.cc.

                                      {
  // AbstractType is an abstract class.
  UNREACHABLE();
  return 0;
}

◆ EnumerateURIs()

void dart::AbstractType::EnumerateURIs ( URIs * uris ) const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21249 of file object.cc.

                                                 {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
}

◆ Equals()

virtual bool dart::AbstractType::Equals ( const Instance & other ) const

inlinevirtual

Definition at line 9094 of file object.h.

                                                   {
    return IsEquivalent(other, TypeEquality::kCanonical);
  }

◆ flags_offset()

static intptr_t dart::AbstractType::flags_offset ( )

inlinestatic

Definition at line 9046 of file object.h.

                                 {
    return OFFSET_OF(UntaggedAbstractType, flags_);
  }

◆ Hash()

uword dart::AbstractType::Hash ( ) const

inline

Definition at line 13377 of file object.h.

                                      {
  ASSERT(IsFinalized());
  intptr_t result = Smi::Value(untag()->hash());
  if (result != 0) {
    return result;
  }
  return ComputeHash();
}

◆ hash_offset()

static intptr_t dart::AbstractType::hash_offset ( )

inlinestatic

Definition at line 9049 of file object.h.

                                {
    return OFFSET_OF(UntaggedAbstractType, hash_);
  }

◆ HasTypeClass()

virtual bool dart::AbstractType::HasTypeClass ( ) const

inlinevirtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 9083 of file object.h.

9083{ return type_class_id() != kIllegalCid; }

dart::AbstractType::type_class_id

virtual classid_t type_class_id() const

Definition: object.cc:21033

dart::kIllegalCid

@ kIllegalCid

Definition: class_id.h:214

◆ HEAP_OBJECT_IMPLEMENTATION()

dart::AbstractType::HEAP_OBJECT_IMPLEMENTATION	(	AbstractType	,
		Instance
	)

protected

◆ InitializeTypeTestingStubNonAtomic()

void dart::AbstractType::InitializeTypeTestingStubNonAtomic ( const Code & stub ) const

Definition at line 21787 of file object.cc.

                                                                            {
  if (stub.IsNull()) {
    // This only happens during bootstrapping when creating Type objects before
    // we have the instructions.
    ASSERT(type_class_id() == kDynamicCid || type_class_id() == kVoidCid);
    StoreNonPointer(&untag()->type_test_stub_entry_point_, 0);
    untag()->set_type_test_stub(stub.ptr());
    return;
  }
 
  StoreNonPointer(&untag()->type_test_stub_entry_point_, stub.EntryPoint());
  untag()->set_type_test_stub(stub.ptr());
}

◆ InstanceSize()

static intptr_t dart::AbstractType::InstanceSize ( )

inlinestatic

Definition at line 9329 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedAbstractType));
  }

◆ InstantiateAndTestSubtype()

bool dart::AbstractType::InstantiateAndTestSubtype	(	AbstractType *	subtype,
		AbstractType *	supertype,
		const TypeArguments &	instantiator_type_args,
		const TypeArguments &	function_type_args
	)

static

Definition at line 4287 of file object.cc.

                                             {
  if (!subtype->IsInstantiated()) {
    *subtype = subtype->InstantiateFrom(
        instantiator_type_args, function_type_args, kAllFree, Heap::kOld);
  }
  if (!supertype->IsInstantiated()) {
    *supertype = supertype->InstantiateFrom(
        instantiator_type_args, function_type_args, kAllFree, Heap::kOld);
  }
  return subtype->IsSubtypeOf(*supertype, Heap::kOld);
}

◆ InstantiateFrom()

AbstractTypePtr dart::AbstractType::InstantiateFrom	(	const TypeArguments &	instantiator_type_arguments,
		const TypeArguments &	function_type_arguments,
		intptr_t	num_free_fun_type_params,
		Heap::Space	space,
		FunctionTypeMapping *	function_type_mapping = `nullptr`,
		intptr_t	num_parent_type_args_adjustment = `0`
	)		const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21216 of file object.cc.

                                                    {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return nullptr;
}

◆ IsBoolType()

bool dart::AbstractType::IsBoolType ( ) const

inline

Definition at line 9222 of file object.h.

9222{ return type_class_id() == kBoolCid; }

◆ IsCatchAllType()

bool dart::AbstractType::IsCatchAllType ( ) const

inline

Definition at line 9276 of file object.h.

9276{ return IsDynamicType() || IsObjectType(); }

dart::AbstractType::IsObjectType

bool IsObjectType() const

Definition: object.h:9201

dart::AbstractType::IsDynamicType

bool IsDynamicType() const

Definition: object.h:9186

◆ IsDartClosureType()

bool dart::AbstractType::IsDartClosureType ( ) const

Definition at line 21456 of file object.cc.

                                           {
  return (type_class_id() == kClosureCid);
}

◆ IsDartFunctionType()

bool dart::AbstractType::IsDartFunctionType ( ) const

Definition at line 21451 of file object.cc.

                                            {
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::DartFunctionType()).type_class());
}

◆ IsDartRecordType()

bool dart::AbstractType::IsDartRecordType ( ) const

Definition at line 21460 of file object.cc.

                                          {
  if (!HasTypeClass()) return false;
  const auto cid = type_class_id();
  return ((cid == kRecordCid) ||
          (cid == Class::Handle(
                      IsolateGroup::Current()->object_store()->record_class())
                      .id()));
}

◆ IsDoubleType()

bool dart::AbstractType::IsDoubleType ( ) const

Definition at line 21423 of file object.cc.

                                      {
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::Double()).type_class());
}

◆ IsDynamicType()

bool dart::AbstractType::IsDynamicType ( ) const

inline

Definition at line 9186 of file object.h.

9186{ return type_class_id() == kDynamicCid; }

◆ IsEquivalent()

bool dart::AbstractType::IsEquivalent	(	const Instance &	other,
		TypeEquality	kind,
		FunctionTypeMapping *	function_type_equivalence = `nullptr`
	)		const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21184 of file object.cc.

                                                          {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return false;
}

◆ IsFfiPointerType()

bool dart::AbstractType::IsFfiPointerType ( ) const

Definition at line 21469 of file object.cc.

                                          {
  return HasTypeClass() && type_class_id() == kPointerCid;
}

◆ IsFinalized()

bool dart::AbstractType::IsFinalized ( ) const

inline

Definition at line 9053 of file object.h.

                           {
    const auto state = type_state();
    return (state == UntaggedAbstractType::kFinalizedInstantiated) ||
           (state == UntaggedAbstractType::kFinalizedUninstantiated);
  }

◆ IsFloat32x4Type()

bool dart::AbstractType::IsFloat32x4Type ( ) const

Definition at line 21428 of file object.cc.

                                         {
  // kFloat32x4Cid refers to the private class and cannot be used here.
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::Float32x4()).type_class());
}

◆ IsFloat64x2Type()

bool dart::AbstractType::IsFloat64x2Type ( ) const

Definition at line 21434 of file object.cc.

                                         {
  // kFloat64x2Cid refers to the private class and cannot be used here.
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::Float64x2()).type_class());
}

◆ IsFutureOrType()

bool dart::AbstractType::IsFutureOrType ( ) const

inline

Definition at line 9267 of file object.h.

9267{ return type_class_id() == kFutureOrCid; }

◆ IsInstantiated()

bool dart::AbstractType::IsInstantiated	(	Genericity	genericity = `kAny`,
		intptr_t	num_free_fun_type_params = `kAllFree`
	)		const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21151 of file object.cc.

                                                                           {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return false;
}

◆ IsInt32x4Type()

bool dart::AbstractType::IsInt32x4Type ( ) const

Definition at line 21440 of file object.cc.

                                       {
  // kInt32x4Cid refers to the private class and cannot be used here.
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::Int32x4()).type_class());
}

◆ IsIntegerImplementationType()

bool dart::AbstractType::IsIntegerImplementationType ( ) const

Definition at line 21416 of file object.cc.

                                                     {
  return HasTypeClass() &&
         (type_class() == IsolateGroup::Current()
                              ->object_store()
                              ->integer_implementation_class());
}

◆ IsIntType()

bool dart::AbstractType::IsIntType ( ) const

Definition at line 21411 of file object.cc.

                                   {
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::IntType()).type_class());
}

◆ IsMintType()

bool dart::AbstractType::IsMintType ( ) const

inline

Definition at line 9249 of file object.h.

9249{ return type_class_id() == kMintCid; }

◆ IsNeverType()

bool dart::AbstractType::IsNeverType ( ) const

Definition at line 21371 of file object.cc.

                                     {
  return type_class_id() == kNeverCid;
}

◆ IsNonNullable()

bool dart::AbstractType::IsNonNullable ( ) const

inline

Definition at line 9071 of file object.h.

                             {
    return nullability() == Nullability::kNonNullable;
  }

◆ IsNullabilityEquivalent()

bool dart::AbstractType::IsNullabilityEquivalent	(	Thread *	thread,
		const AbstractType &	other_type,
		TypeEquality	kind
	)		const

protected

Definition at line 21196 of file object.cc.

                                                                    {
  Nullability this_type_nullability = nullability();
  Nullability other_type_nullability = other_type.nullability();
  if (kind == TypeEquality::kInSubtypeTest) {
    if (this_type_nullability == Nullability::kNullable &&
        other_type_nullability == Nullability::kNonNullable) {
      return false;
    }
  } else {
    ASSERT((kind == TypeEquality::kSyntactical) ||
           (kind == TypeEquality::kCanonical));
    if (this_type_nullability != other_type_nullability) {
      return false;
    }
  }
  return true;
}

◆ IsNullable()

bool dart::AbstractType::IsNullable ( ) const

inline

Definition at line 9066 of file object.h.

9066{ return nullability() == Nullability::kNullable; }

◆ IsNullableObjectType()

bool dart::AbstractType::IsNullableObjectType ( ) const

inline

Definition at line 9204 of file object.h.

                                    {
    return IsObjectType() && (nullability() == Nullability::kNullable);
  }

◆ IsNullType()

bool dart::AbstractType::IsNullType ( ) const

Definition at line 21367 of file object.cc.

                                    {
  return type_class_id() == kNullCid;
}

◆ IsNumberType()

bool dart::AbstractType::IsNumberType ( ) const

inline

Definition at line 9243 of file object.h.

9243{ return type_class_id() == kNumberCid; }

◆ IsObjectType()

bool dart::AbstractType::IsObjectType ( ) const

inline

Definition at line 9201 of file object.h.

9201{ return type_class_id() == kInstanceCid; }

◆ IsSentinelType()

bool dart::AbstractType::IsSentinelType ( ) const

Definition at line 21375 of file object.cc.

                                        {
  return type_class_id() == kSentinelCid;
}

◆ IsSmiType()

bool dart::AbstractType::IsSmiType ( ) const

inline

Definition at line 9246 of file object.h.

9246{ return type_class_id() == kSmiCid; }

◆ IsStrictlyNonNullable()

bool dart::AbstractType::IsStrictlyNonNullable ( ) const

Definition at line 21060 of file object.cc.

                                               {
  // Null can be assigned to legacy and nullable types.
  if (!IsNonNullable()) {
    return false;
  }
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  if (IsTypeParameter()) {
    const auto& bound =
        AbstractType::Handle(zone, TypeParameter::Cast(*this).bound());
    ASSERT(!bound.IsNull());
    return bound.IsStrictlyNonNullable();
  }
  if (IsFutureOrType()) {
    return AbstractType::Handle(zone, UnwrapFutureOr()).IsStrictlyNonNullable();
  }
  return true;
}

◆ IsStringType()

bool dart::AbstractType::IsStringType ( ) const

Definition at line 21446 of file object.cc.

                                      {
  return HasTypeClass() &&
         (type_class() == Type::Handle(Type::StringType()).type_class());
}

◆ IsSubtypeOf()

bool dart::AbstractType::IsSubtypeOf	(	const AbstractType &	other,
		Heap::Space	space,
		FunctionTypeMapping *	function_type_equivalence = `nullptr`
	)		const

Definition at line 21550 of file object.cc.

                                                          {
  TRACE_TYPE_CHECKS_VERBOSE("  AbstractType::IsSubtypeOf(%s, %s)\n",
                            ToCString(), other.ToCString());
  ASSERT(IsFinalized());
  ASSERT(other.IsFinalized());
  // Reflexivity.
  if (ptr() == other.ptr()) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: true (same types)\n");
    return true;
  }
  // Right top type.
  if (other.IsTopTypeForSubtyping()) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: true (right is top)\n");
    return true;
  }
  // Left bottom type.
  // Any form of Never in weak mode maps to Null and Null is a bottom type in
  // weak mode. In strong mode, Never and Never* are bottom types. Therefore,
  // Never and Never* are bottom types regardless of weak/strong mode.
  // Note that we cannot encounter Never?, as it is normalized to Null.
  if (IsNeverType()) {
    ASSERT(!IsNullable());
    TRACE_TYPE_CHECKS_VERBOSE("   - result: true (left is Never)\n");
    return true;
  }
  // Left top type.
  if (IsDynamicType() || IsVoidType()) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: false (left is top)\n");
    return false;
  }
  // Left Null type.
  if (IsNullType()) {
    const bool result = Instance::NullIsAssignableTo(other);
    TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (left is Null)\n",
                              (result ? "true" : "false"));
    return result;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  // Type parameters cannot be handled by Class::IsSubtypeOf().
  // When comparing two uninstantiated function types, one returning type
  // parameter K, the other returning type parameter V, we cannot assume that
  // K is a subtype of V, or vice versa. We only return true if K equals V, as
  // defined by TypeParameter::Equals.
  // The same rule applies when checking the upper bound of a still
  // uninstantiated type at compile time. Returning false will defer the test
  // to run time.
  // There are however some cases that can be decided at compile time.
  // For example, with class A<K, V extends K>, new A<T, T> called from within
  // a class B<T> will never require a run time bound check, even if T is
  // uninstantiated at compile time.
  if (IsTypeParameter()) {
    const TypeParameter& type_param = TypeParameter::Cast(*this);
    if (other.IsTypeParameter()) {
      const TypeParameter& other_type_param = TypeParameter::Cast(other);
      if (type_param.IsEquivalent(other_type_param,
                                  TypeEquality::kInSubtypeTest,
                                  function_type_equivalence)) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: true (equivalent type parameters)\n");
        return true;
      }
    }
    const AbstractType& bound = AbstractType::Handle(zone, type_param.bound());
    ASSERT(bound.IsFinalized());
    if (bound.IsSubtypeOf(other, space, function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE("   - result: true (bound is a subtype)\n");
      return true;
    }
    // Apply additional subtyping rules if 'other' is 'FutureOr'.
    if (IsSubtypeOfFutureOr(zone, other, space, function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: true (type parameter is a subtype of FutureOr)\n");
      return true;
    }
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (left is a type parameter)\n");
    return false;
  }
  if (other.IsTypeParameter()) {
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (right is a type parameter)\n");
    return false;
  }
  // Function types cannot be handled by Class::IsSubtypeOf().
  if (IsFunctionType()) {
    // Any type that can be the type of a closure is a subtype of Function or
    // non-nullable Object.
    if (other.IsObjectType() || other.IsDartFunctionType()) {
      const bool result = !IsNullable() || !other.IsNonNullable();
      TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (function vs non-function)\n",
                                (result ? "true" : "false"));
      return result;
    }
    if (other.IsFunctionType()) {
      // Check for two function types.
      if (IsNullable() && other.IsNonNullable()) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: false (function nullability)\n");
        return false;
      }
      const bool result = FunctionType::Cast(*this).IsSubtypeOf(
          FunctionType::Cast(other), space, function_type_equivalence);
      TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (function types)\n",
                                (result ? "true" : "false"));
      return result;
    }
    // Apply additional subtyping rules if 'other' is 'FutureOr'.
    if (IsSubtypeOfFutureOr(zone, other, space, function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: true (function type is a subtype of FutureOr)\n");
      return true;
    }
    // All possible supertypes for FunctionType have been checked.
    TRACE_TYPE_CHECKS_VERBOSE("   - result: false (function type)\n");
    return false;
  } else if (other.IsFunctionType()) {
    // FunctionTypes can only be subtyped by other FunctionTypes, so don't
    // fall through to class-based type tests.
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (right is a function type)\n");
    return false;
  }
  // Record types cannot be handled by Class::IsSubtypeOf().
  if (IsRecordType()) {
    if (other.IsObjectType() || other.IsDartRecordType()) {
      const bool result = !IsNullable() || !other.IsNonNullable();
      TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (record vs non-record)\n",
                                (result ? "true" : "false"));
      return result;
    }
    if (other.IsRecordType()) {
      // Check for two record types.
      if (IsNullable() && other.IsNonNullable()) {
        TRACE_TYPE_CHECKS_VERBOSE("   - result: false (record nullability)\n");
        return false;
      }
      const bool result = RecordType::Cast(*this).IsSubtypeOf(
          RecordType::Cast(other), space, function_type_equivalence);
      TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (record types)\n",
                                (result ? "true" : "false"));
      return result;
    }
    // Apply additional subtyping rules if 'other' is 'FutureOr'.
    if (IsSubtypeOfFutureOr(zone, other, space, function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: true (record type is a subtype of FutureOr)\n");
      return true;
    }
    // All possible supertypes for record type have been checked.
    TRACE_TYPE_CHECKS_VERBOSE("   - result: false (record type)\n");
    return false;
  } else if (other.IsRecordType()) {
    // RecordTypes can only be subtyped by other RecordTypes, so don't
    // fall through to class-based type tests.
    TRACE_TYPE_CHECKS_VERBOSE("   - result: false (right is a record type)\n");
    return false;
  }
  ASSERT(IsType());
  const Class& type_cls = Class::Handle(zone, type_class());
  const bool result = Class::IsSubtypeOf(
      type_cls,
      TypeArguments::Handle(zone, Type::Cast(*this).GetInstanceTypeArguments(
                                      thread, /*canonicalize=*/false)),
      nullability(), other, space, function_type_equivalence);
  TRACE_TYPE_CHECKS_VERBOSE("   - result: %s (class type check)\n",
                            (result ? "true" : "false"));
  return result;
}

◆ IsTopTypeForInstanceOf()

bool dart::AbstractType::IsTopTypeForInstanceOf ( ) const

Definition at line 21379 of file object.cc.

                                                {
  const classid_t cid = type_class_id();
  if (cid == kDynamicCid || cid == kVoidCid) {
    return true;
  }
  if (cid == kInstanceCid) {  // Object type.
    return IsNullable();
  }
  if (cid == kFutureOrCid) {
    // FutureOr<T> where T is a top type behaves as a top type.
    return AbstractType::Handle(UnwrapFutureOr()).IsTopTypeForInstanceOf();
  }
  return false;
}

◆ IsTopTypeForSubtyping()

bool dart::AbstractType::IsTopTypeForSubtyping ( ) const

Definition at line 21396 of file object.cc.

                                               {
  const classid_t cid = type_class_id();
  if (cid == kDynamicCid || cid == kVoidCid) {
    return true;
  }
  if (cid == kInstanceCid) {  // Object type.
    return !IsNonNullable();
  }
  if (cid == kFutureOrCid) {
    // FutureOr<T> where T is a top type behaves as a top type.
    return AbstractType::Handle(UnwrapFutureOr()).IsTopTypeForSubtyping();
  }
  return false;
}

◆ IsTypeClassAllowedBySpawnUri()

bool dart::AbstractType::IsTypeClassAllowedBySpawnUri ( ) const

Definition at line 21473 of file object.cc.

                                                      {
  if (!HasTypeClass()) return false;
 
  intptr_t cid = type_class_id();
 
  if (cid == kBoolCid) return true;
  if (cid == kDynamicCid) return true;
  if (cid == kInstanceCid) return true;  // Object.
  if (cid == kNeverCid) return true;
  if (cid == kNullCid) return true;
  if (cid == kVoidCid) return true;
 
  // These are not constant CID checks because kDoubleCid refers to _Double
  // not double, etc.
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  Type& candidate_type = Type::Handle();
  candidate_type = object_store->int_type();
  if (cid == candidate_type.type_class_id()) return true;
  candidate_type = object_store->double_type();
  if (cid == candidate_type.type_class_id()) return true;
  candidate_type = object_store->number_type();
  if (cid == candidate_type.type_class_id()) return true;
  candidate_type = object_store->string_type();
  if (cid == candidate_type.type_class_id()) return true;
 
  Class& candidate_cls = Class::Handle();
  candidate_cls = object_store->list_class();
  if (cid == candidate_cls.id()) return true;
  candidate_cls = object_store->map_class();
  if (cid == candidate_cls.id()) return true;
  candidate_cls = object_store->set_class();
  if (cid == candidate_cls.id()) return true;
  candidate_cls = object_store->capability_class();
  if (cid == candidate_cls.id()) return true;
  candidate_cls = object_store->send_port_class();
  if (cid == candidate_cls.id()) return true;
  candidate_cls = object_store->transferable_class();
  if (cid == candidate_cls.id()) return true;
 
  const auto& typed_data_lib =
      Library::Handle(object_store->typed_data_library());
 
#define IS_CHECK(name)                                                         \
  candidate_cls = typed_data_lib.LookupClass(Symbols::name##List());           \
  if (cid == candidate_cls.id()) {                                             \
    return true;                                                               \
  }
  DART_CLASS_LIST_TYPED_DATA(IS_CHECK)
#undef IS_CHECK
 
  return false;
}

◆ IsVoidType()

bool dart::AbstractType::IsVoidType ( ) const

inline

Definition at line 9189 of file object.h.

9189{ return type_class_id() == kVoidCid; }

◆ Name()

StringPtr dart::AbstractType::Name ( ) const

Definition at line 21320 of file object.cc.

                                   {
  return Symbols::New(Thread::Current(), NameCString());
}

◆ NameCString()

const char * dart::AbstractType::NameCString ( ) const

Definition at line 21324 of file object.cc.

                                            {
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  PrintName(kInternalName, &printer);
  return printer.buffer();
}

◆ NextFieldOffset()

static intptr_t dart::AbstractType::NextFieldOffset ( )

inlinestatic

Definition at line 9333 of file object.h.

9333{ return -kWordSize; }

dart::kWordSize

constexpr intptr_t kWordSize

Definition: globals.h:509

◆ NormalizeFutureOrType()

AbstractTypePtr dart::AbstractType::NormalizeFutureOrType ( Heap::Space space ) const

virtual

Definition at line 21115 of file object.cc.

                                                                         {
  if (IsFutureOrType()) {
    Zone* zone = Thread::Current()->zone();
    const AbstractType& unwrapped_type =
        AbstractType::Handle(zone, UnwrapFutureOr());
    const classid_t cid = unwrapped_type.type_class_id();
    if (cid == kDynamicCid || cid == kVoidCid) {
      return unwrapped_type.ptr();
    }
    if (cid == kInstanceCid) {
      if (IsNonNullable()) {
        return unwrapped_type.ptr();
      }
      ASSERT(IsNullable());
      return Type::Cast(unwrapped_type)
          .ToNullability(Nullability::kNullable, space);
    }
    if (cid == kNeverCid && unwrapped_type.IsNonNullable()) {
      ObjectStore* object_store = IsolateGroup::Current()->object_store();
      const Type& future_never_type =
          Type::Handle(zone, object_store->non_nullable_future_never_type());
      ASSERT(!future_never_type.IsNull());
      return future_never_type.ToNullability(nullability(), space);
    }
    if (cid == kNullCid) {
      ObjectStore* object_store = IsolateGroup::Current()->object_store();
      ASSERT(object_store->nullable_future_null_type() != Type::null());
      return object_store->nullable_future_null_type();
    }
    if (IsNullable() && unwrapped_type.IsNullable()) {
      return Type::Cast(*this).ToNullability(Nullability::kNonNullable, space);
    }
  }
  return ptr();
}

◆ nullability()

Nullability dart::AbstractType::nullability ( ) const

inline

Definition at line 9060 of file object.h.

                                  {
    return static_cast<Nullability>(
        UntaggedAbstractType::NullabilityBit::decode(untag()->flags()));
  }

◆ NullabilitySuffix()

const char * dart::AbstractType::NullabilitySuffix ( NameVisibility name_visibility ) const

virtual

Definition at line 21303 of file object.cc.

                                          {
  if (IsDynamicType() || IsVoidType() || IsNullType()) {
    // Hide nullable suffix.
    return "";
  }
  // Keep in sync with Nullability enum in runtime/vm/object.h.
  switch (nullability()) {
    case Nullability::kNullable:
      return "?";
    case Nullability::kNonNullable:
      return "";
    default:
      UNREACHABLE();
  }
}

◆ PrintName()

void dart::AbstractType::PrintName	(	NameVisibility	visibility,
		BaseTextBuffer *	printer
	)		const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21353 of file object.cc.

                                                            {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
}

◆ PrintURIs()

StringPtr dart::AbstractType::PrintURIs ( URIs * uris )

static

Definition at line 21283 of file object.cc.

                                            {
  ASSERT(uris != nullptr);
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const intptr_t len = uris->length();
  ASSERT((len % 3) == 0);
  GrowableHandlePtrArray<const String> pieces(zone, 5 * (len / 3));
  for (intptr_t i = 0; i < len; i += 3) {
    // Only print URIs that have been marked.
    if (uris->At(i + 2).ptr() == Symbols::print().ptr()) {
      pieces.Add(Symbols::TwoSpaces());
      pieces.Add(uris->At(i));
      pieces.Add(Symbols::SpaceIsFromSpace());
      pieces.Add(uris->At(i + 1));
      pieces.Add(Symbols::NewLine());
    }
  }
  return Symbols::FromConcatAll(thread, pieces);
}

◆ ScrubbedName()

StringPtr dart::AbstractType::ScrubbedName ( ) const

Definition at line 21342 of file object.cc.

                                           {
  return Symbols::New(Thread::Current(), ScrubbedNameCString());
}

◆ ScrubbedNameCString()

const char * dart::AbstractType::ScrubbedNameCString ( ) const

Definition at line 21346 of file object.cc.

                                                    {
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  PrintName(kScrubbedName, &printer);
  return printer.buffer();
}

◆ set_flags()

void dart::AbstractType::set_flags ( uint32_t value ) const

protected

Definition at line 21168 of file object.cc.

                                                 {
  untag()->set_flags(value);
}

◆ set_nullability()

void dart::AbstractType::set_nullability ( Nullability value ) const

protected

Definition at line 21178 of file object.cc.

                                                          {
  ASSERT(!IsCanonical());
  set_flags(UntaggedAbstractType::NullabilityBit::update(
      static_cast<uint8_t>(value), untag()->flags()));
}

◆ set_type_state()

void dart::AbstractType::set_type_state ( UntaggedAbstractType::TypeState value ) const

protected

Definition at line 21172 of file object.cc.

                                                                           {
  ASSERT(!IsCanonical());
  set_flags(
      UntaggedAbstractType::TypeStateBits::update(value, untag()->flags()));
}

◆ SetHash()

void dart::AbstractType::SetHash ( intptr_t value ) const

inlineprotected

Definition at line 13386 of file object.h.

                                                      {
  // This is only safe because we create a new Smi, which does not cause
  // heap allocation.
  untag()->set_hash(Smi::New(value));
}

◆ SetInstantiatedNullability()

AbstractTypePtr dart::AbstractType::SetInstantiatedNullability	(	const TypeParameter &	type_param,
		Heap::Space	space
	)		const

virtual

Definition at line 21081 of file object.cc.

                           {
  Nullability result_nullability;
  const Nullability arg_nullability = nullability();
  const Nullability var_nullability = type_param.nullability();
  // Adjust nullability of result 'arg' instantiated from 'var'.
  // arg/var ! ?
  //  !      ! ?
  //  ?      ? ?
  if (var_nullability == Nullability::kNullable) {
    result_nullability = Nullability::kNullable;
  } else {
    // Keep arg nullability.
    return ptr();
  }
  if (arg_nullability == result_nullability) {
    return ptr();
  }
  if (IsType()) {
    return Type::Cast(*this).ToNullability(result_nullability, space);
  }
  if (IsFunctionType()) {
    return FunctionType::Cast(*this).ToNullability(result_nullability, space);
  }
  if (IsRecordType()) {
    return RecordType::Cast(*this).ToNullability(result_nullability, space);
  }
  if (IsTypeParameter()) {
    return TypeParameter::Cast(*this).ToNullability(result_nullability, space);
  }
  UNREACHABLE();
}

◆ SetIsFinalized()

void dart::AbstractType::SetIsFinalized ( ) const

Definition at line 21161 of file object.cc.

                                        {
  ASSERT(!IsFinalized());
  set_type_state(IsInstantiated()
                     ? UntaggedAbstractType::kFinalizedInstantiated
                     : UntaggedAbstractType::kFinalizedUninstantiated);
}

◆ SetTypeTestingStub()

void dart::AbstractType::SetTypeTestingStub ( const Code & stub ) const

Definition at line 21761 of file object.cc.

                                                            {
  if (stub.IsNull()) {
    InitializeTypeTestingStubNonAtomic(stub);
    return;
  }
 
  auto& old = Code::Handle(Thread::Current()->zone());
  while (true) {
    // We load the old TTS and it's entrypoint.
    old = untag()->type_test_stub<std::memory_order_acquire>();
    uword old_entry_point = old.IsNull() ? 0 : old.EntryPoint();
 
    // If we can successfully update the entrypoint of the TTS, we will
    // unconditionally also set the [Code] of the TTS.
    //
    // Any competing writer would do the same, lose the compare-exchange, loop
    // around and continue loading the old [Code] TTS and continue to lose the
    // race until we have finally also updated the [Code] TTS.
    if (untag()->type_test_stub_entry_point_.compare_exchange_strong(
            old_entry_point, stub.EntryPoint())) {
      untag()->set_type_test_stub<std::memory_order_release>(stub.ptr());
      return;
    }
  }
}

◆ type_class()

ClassPtr dart::AbstractType::type_class ( ) const

virtual

Reimplemented in dart::Type.

Definition at line 21042 of file object.cc.

                                        {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return Class::null();
}

◆ type_class_id()

classid_t dart::AbstractType::type_class_id ( ) const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21033 of file object.cc.

                                            {
  // All subclasses should implement this appropriately, so the only value that
  // should reach this implementation should be the null value.
  ASSERT(IsNull());
  // AbstractType is an abstract class.
  UNREACHABLE();
  return kIllegalCid;
}

◆ type_state()

UntaggedAbstractType::TypeState dart::AbstractType::type_state ( ) const

inlineprotected

Definition at line 9351 of file object.h.

                                                   {
    return static_cast<UntaggedAbstractType::TypeState>(
        UntaggedAbstractType::TypeStateBits::decode(untag()->flags()));
  }

◆ type_test_stub()

CodePtr dart::AbstractType::type_test_stub ( ) const

inline

Definition at line 9304 of file object.h.

9304{ return untag()->type_test_stub(); }

◆ type_test_stub_entry_point()

uword dart::AbstractType::type_test_stub_entry_point ( ) const

inline

Definition at line 9301 of file object.h.

                                           {
    return untag()->type_test_stub_entry_point_;
  }

◆ type_test_stub_entry_point_offset()

static intptr_t dart::AbstractType::type_test_stub_entry_point_offset ( )

inlinestatic

Definition at line 9297 of file object.h.

                                                      {
    return OFFSET_OF(UntaggedAbstractType, type_test_stub_entry_point_);
  }

◆ UnwrapFutureOr()

AbstractTypePtr dart::AbstractType::UnwrapFutureOr ( ) const

Definition at line 21526 of file object.cc.

                                                   {
  if (!IsFutureOrType()) {
    return ptr();
  }
  if (arguments() == TypeArguments::null()) {
    return Type::dynamic_type().ptr();
  }
  Thread* thread = Thread::Current();
  REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
  TypeArguments& type_args = thread->TypeArgumentsHandle();
  type_args = arguments();
  REUSABLE_ABSTRACT_TYPE_HANDLESCOPE(thread);
  AbstractType& type_arg = thread->AbstractTypeHandle();
  type_arg = type_args.TypeAt(0);
  while (type_arg.IsFutureOrType()) {
    if (type_arg.arguments() == TypeArguments::null()) {
      return Type::dynamic_type().ptr();
    }
    type_args = type_arg.arguments();
    type_arg = type_args.TypeAt(0);
  }
  return type_arg.ptr();
}

◆ UpdateFunctionTypes()

AbstractTypePtr dart::AbstractType::UpdateFunctionTypes	(	intptr_t	num_parent_type_args_adjustment,
		intptr_t	num_free_fun_type_params,
		Heap::Space	space,
		FunctionTypeMapping *	function_type_mapping
	)		const

virtual

Reimplemented in dart::Type, dart::FunctionType, dart::TypeParameter, and dart::RecordType.

Definition at line 21231 of file object.cc.

                                                      {
  UNREACHABLE();
  return nullptr;
}

◆ UpdateTypeTestingStubEntryPoint()

void dart::AbstractType::UpdateTypeTestingStubEntryPoint ( ) const

inline

Definition at line 9322 of file object.h.

                                               {
    StoreNonPointer(&untag()->type_test_stub_entry_point_,
                    Code::EntryPointOf(untag()->type_test_stub()));
  }

◆ UserVisibleName()

StringPtr dart::AbstractType::UserVisibleName ( ) const

Definition at line 21331 of file object.cc.

                                              {
  return Symbols::New(Thread::Current(), UserVisibleNameCString());
}

◆ UserVisibleNameCString()

const char * dart::AbstractType::UserVisibleNameCString ( ) const

Definition at line 21335 of file object.cc.

                                                       {
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  PrintName(kUserVisibleName, &printer);
  return printer.buffer();
}

Friends And Related Function Documentation

◆ Class

friend class Class

friend

Definition at line 9360 of file object.h.

◆ ClearTypeHashVisitor

friend class ClearTypeHashVisitor

friend

Definition at line 9361 of file object.h.

◆ Function

friend class Function

friend

Definition at line 9362 of file object.h.

◆ TypeArguments

friend class TypeArguments

friend

Definition at line 9363 of file object.h.

The documentation for this class was generated from the following files:

third_party/dart-lang/sdk/runtime/vm/object.h
third_party/dart-lang/sdk/runtime/vm/object.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ AddURI()

◆ arguments()

◆ Canonicalize()

◆ CanonicalizeEquals()

◆ CanonicalizeHash()

◆ CanonicalizeLocked()

◆ ClassName()

◆ ComputeHash()

◆ EnumerateURIs()

◆ Equals()

◆ flags_offset()

◆ Hash()

◆ hash_offset()

◆ HasTypeClass()

◆ HEAP_OBJECT_IMPLEMENTATION()

◆ InitializeTypeTestingStubNonAtomic()

◆ InstanceSize()

◆ InstantiateAndTestSubtype()

◆ InstantiateFrom()

◆ IsBoolType()

◆ IsCatchAllType()

◆ IsDartClosureType()

◆ IsDartFunctionType()

◆ IsDartRecordType()

◆ IsDoubleType()

◆ IsDynamicType()

◆ IsEquivalent()

◆ IsFfiPointerType()

◆ IsFinalized()

◆ IsFloat32x4Type()

◆ IsFloat64x2Type()

◆ IsFutureOrType()

◆ IsInstantiated()

◆ IsInt32x4Type()

◆ IsIntegerImplementationType()

◆ IsIntType()

◆ IsMintType()

◆ IsNeverType()

◆ IsNonNullable()

◆ IsNullabilityEquivalent()

◆ IsNullable()

◆ IsNullableObjectType()

◆ IsNullType()

◆ IsNumberType()

◆ IsObjectType()

◆ IsSentinelType()

◆ IsSmiType()

◆ IsStrictlyNonNullable()

◆ IsStringType()

◆ IsSubtypeOf()

◆ IsTopTypeForInstanceOf()

◆ IsTopTypeForSubtyping()

◆ IsTypeClassAllowedBySpawnUri()

◆ IsVoidType()

◆ Name()

◆ NameCString()

◆ NextFieldOffset()

◆ NormalizeFutureOrType()

◆ nullability()

◆ NullabilitySuffix()

◆ PrintName()

◆ PrintURIs()

◆ ScrubbedName()

◆ ScrubbedNameCString()

◆ set_flags()

◆ set_nullability()

◆ set_type_state()

◆ SetHash()

◆ SetInstantiatedNullability()

◆ SetIsFinalized()

◆ SetTypeTestingStub()

◆ type_class()

◆ type_class_id()