#include <object.h>

Inheritance diagram for dart::Class:

Public Types
enum	InvocationDispatcherEntry { kInvocationDispatcherName , kInvocationDispatcherArgsDesc , kInvocationDispatcherFunction , kInvocationDispatcherEntrySize }

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

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Public Member Functions
bool	HasCompressedPointers () const

intptr_t	host_instance_size () const

intptr_t	target_instance_size () const

void	set_instance_size (intptr_t host_value_in_bytes, intptr_t target_value_in_bytes) const

void	set_instance_size_in_words (intptr_t host_value, intptr_t target_value) const

intptr_t	host_next_field_offset () const

intptr_t	target_next_field_offset () const

void	set_next_field_offset (intptr_t host_value_in_bytes, intptr_t target_value_in_bytes) const

void	set_next_field_offset_in_words (intptr_t host_value, intptr_t target_value) const

intptr_t	id () const

void	set_id (intptr_t value) const

intptr_t	implementor_cid () const

bool	NoteImplementor (const Class &implementor) const

StringPtr	Name () const

StringPtr	ScrubbedName () const

const char *	ScrubbedNameCString () const

StringPtr	UserVisibleName () const

const char *	UserVisibleNameCString () const

const char *	NameCString (NameVisibility name_visibility) const

ClassPtr	Mixin () const

bool	IsInFullSnapshot () const

virtual StringPtr	DictionaryName () const

ScriptPtr	script () const

void	set_script (const Script &value) const

KernelProgramInfoPtr	KernelProgramInfo () const

TokenPosition	token_pos () const

void	set_token_pos (TokenPosition value) const

TokenPosition	end_token_pos () const

void	set_end_token_pos (TokenPosition value) const

uint32_t	Hash () const

int32_t	SourceFingerprint () const

TypePtr	RareType () const

TypePtr	DeclarationType () const

TypeArgumentsPtr	GetDeclarationInstanceTypeArguments () const

TypeArgumentsPtr	GetInstanceTypeArguments (Thread *thread, const TypeArguments &type_arguments, bool canonicalize=true) const

LibraryPtr	library () const

void	set_library (const Library &value) const

TypeParametersPtr	type_parameters () const

void	set_type_parameters (const TypeParameters &value) const

intptr_t	NumTypeParameters (Thread *thread) const

intptr_t	NumTypeParameters () const

TypeParameterPtr	TypeParameterAt (intptr_t index, Nullability nullability=Nullability::kNonNullable) const

intptr_t	NumTypeArguments () const

bool	IsGeneric () const

TypeArgumentsPtr	DefaultTypeArguments (Zone *zone) const

intptr_t	host_type_arguments_field_offset () const

intptr_t	target_type_arguments_field_offset () const

void	set_type_arguments_field_offset (intptr_t host_value_in_bytes, intptr_t target_value_in_bytes) const

void	set_type_arguments_field_offset_in_words (intptr_t host_value, intptr_t target_value) const

TypePtr	super_type () const

void	set_super_type (const Type &value) const

ClassPtr	SuperClass (ClassTable *class_table=nullptr) const

ArrayPtr	interfaces () const

void	set_interfaces (const Array &value) const

bool	FindInstantiationOf (Zone zone, const Class &cls, GrowableArray< const Type > *path, bool consider_only_super_classes=false) const

bool	FindInstantiationOf (Zone *zone, const Class &cls, bool consider_only_super_classes=false) const

bool	FindInstantiationOf (Zone zone, const Type &type, GrowableArray< const Type > *path, bool consider_only_super_classes=false) const

bool	FindInstantiationOf (Zone *zone, const Type &type, bool consider_only_super_classes=false) const

TypePtr	GetInstantiationOf (Zone *zone, const Class &cls) const

TypePtr	GetInstantiationOf (Zone *zone, const Type &type) const

GrowableObjectArrayPtr	direct_implementors () const

GrowableObjectArrayPtr	direct_implementors_unsafe () const

void	set_direct_implementors (const GrowableObjectArray &implementors) const

void	AddDirectImplementor (const Class &subclass, bool is_mixin) const

GrowableObjectArrayPtr	direct_subclasses () const

GrowableObjectArrayPtr	direct_subclasses_unsafe () const

void	set_direct_subclasses (const GrowableObjectArray &subclasses) const

void	AddDirectSubclass (const Class &subclass) const

bool	IsNullClass () const

bool	IsDynamicClass () const

bool	IsVoidClass () const

bool	IsNeverClass () const

bool	IsObjectClass () const

bool	IsDartFunctionClass () const

bool	IsFutureClass () const

bool	IsFutureOrClass () const

bool	IsClosureClass () const

bool	IsRecordClass () const

bool	IsTopLevel () const

bool	IsPrivate () const

DART_WARN_UNUSED_RESULT ErrorPtr	VerifyEntryPoint () const

ArrayPtr	fields () const

void	SetFields (const Array &value) const

void	AddField (const Field &field) const

void	AddFields (const GrowableArray< const Field * > &fields) const

intptr_t	FindFieldIndex (const Field &needle) const

FieldPtr	FieldFromIndex (intptr_t idx) const

bool	InjectCIDFields () const

ArrayPtr	OffsetToFieldMap (ClassTable *class_table=nullptr) const

bool	HasInstanceFields () const

ArrayPtr	current_functions () const

ArrayPtr	functions () const

void	SetFunctions (const Array &value) const

void	AddFunction (const Function &function) const

intptr_t	FindFunctionIndex (const Function &needle) const

FunctionPtr	FunctionFromIndex (intptr_t idx) const

intptr_t	FindImplicitClosureFunctionIndex (const Function &needle) const

FunctionPtr	ImplicitClosureFunctionFromIndex (intptr_t idx) const

FunctionPtr	LookupFunctionReadLocked (const String &name) const

FunctionPtr	LookupDynamicFunctionUnsafe (const String &name) const

FunctionPtr	LookupDynamicFunctionAllowPrivate (const String &name) const

FunctionPtr	LookupStaticFunction (const String &name) const

FunctionPtr	LookupStaticFunctionAllowPrivate (const String &name) const

FunctionPtr	LookupConstructor (const String &name) const

FunctionPtr	LookupConstructorAllowPrivate (const String &name) const

FunctionPtr	LookupFactory (const String &name) const

FunctionPtr	LookupFactoryAllowPrivate (const String &name) const

FunctionPtr	LookupFunctionAllowPrivate (const String &name) const

FunctionPtr	LookupGetterFunction (const String &name) const

FunctionPtr	LookupSetterFunction (const String &name) const

FieldPtr	LookupInstanceField (const String &name) const

FieldPtr	LookupStaticField (const String &name) const

FieldPtr	LookupField (const String &name) const

FieldPtr	LookupFieldAllowPrivate (const String &name, bool instance_only=false) const

FieldPtr	LookupInstanceFieldAllowPrivate (const String &name) const

FieldPtr	LookupStaticFieldAllowPrivate (const String &name) const

InstancePtr	LookupCanonicalInstance (Zone *zone, const Instance &value) const

InstancePtr	InsertCanonicalConstant (Zone *zone, const Instance &constant) const

bool	is_implemented () const

void	set_is_implemented () const

void	set_is_implemented_unsafe () const

bool	is_abstract () const

void	set_is_abstract () const

UntaggedClass::ClassLoadingState	class_loading_state () const

bool	is_declaration_loaded () const

void	set_is_declaration_loaded () const

void	set_is_declaration_loaded_unsafe () const

bool	is_type_finalized () const

void	set_is_type_finalized () const

bool	is_synthesized_class () const

void	set_is_synthesized_class () const

void	set_is_synthesized_class_unsafe () const

bool	is_enum_class () const

void	set_is_enum_class () const

bool	is_finalized () const

void	set_is_finalized () const

void	set_is_finalized_unsafe () const

bool	is_allocate_finalized () const

void	set_is_allocate_finalized () const

bool	is_prefinalized () const

void	set_is_prefinalized () const

bool	is_const () const

void	set_is_const () const

bool	is_transformed_mixin_application () const

void	set_is_transformed_mixin_application () const

bool	is_sealed () const

void	set_is_sealed () const

bool	is_mixin_class () const

void	set_is_mixin_class () const

bool	is_base_class () const

void	set_is_base_class () const

bool	is_interface_class () const

void	set_is_interface_class () const

bool	is_final () const

void	set_is_final () const

bool	is_fields_marked_nullable () const

void	set_is_fields_marked_nullable () const

bool	is_allocated () const

void	set_is_allocated (bool value) const

void	set_is_allocated_unsafe (bool value) const

bool	is_loaded () const

void	set_is_loaded (bool value) const

uint16_t	num_native_fields () const

void	set_num_native_fields (uint16_t value) const

CodePtr	allocation_stub () const

void	set_allocation_stub (const Code &value) const

intptr_t	kernel_offset () const

void	set_kernel_offset (intptr_t value) const

void	DisableAllocationStub () const

ArrayPtr	constants () const

void	set_constants (const Array &value) const

intptr_t	FindInvocationDispatcherFunctionIndex (const Function &needle) const

FunctionPtr	InvocationDispatcherFunctionFromIndex (intptr_t idx) const

FunctionPtr	GetInvocationDispatcher (const String &target_name, const Array &args_desc, UntaggedFunction::Kind kind, bool create_if_absent) const

FunctionPtr	GetRecordFieldGetter (const String &getter_name) const

void	Finalize () 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 throw_nsm_if_absent, 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 ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &param_values, const TypeArguments &type_param_values) const

void	EnsureDeclarationLoaded () const

ErrorPtr	EnsureIsFinalized (Thread *thread) const

ErrorPtr	EnsureIsAllocateFinalized (Thread *thread) const

void	RegisterCHACode (const Code &code)

void	DisableCHAOptimizedCode (const Class &subclass)

void	DisableAllCHAOptimizedCode ()

void	DisableCHAImplementorUsers ()

WeakArrayPtr	dependent_code () const

void	set_dependent_code (const WeakArray &array) const

bool	TraceAllocation (IsolateGroup *isolate_group) const

void	SetTraceAllocation (bool trace_allocation) const

void	CopyStaticFieldValues (ProgramReloadContext *reload_context, const Class &old_cls) const

void	PatchFieldsAndFunctions () const

void	MigrateImplicitStaticClosures (ProgramReloadContext *context, const Class &new_cls) const

void	CopyCanonicalConstants (const Class &old_cls) const

void	CopyDeclarationType (const Class &old_cls) const

void	CheckReload (const Class &replacement, ProgramReloadContext *context) const

void	AddInvocationDispatcher (const String &target_name, const Array &args_desc, const Function &dispatcher) const

void	MarkFieldBoxedDuringReload (ClassTable *class_table, const Field &field) const

void	SetUserVisibleNameInClassTable ()

void	set_num_type_arguments (intptr_t value) const

void	set_num_type_arguments_unsafe (intptr_t value) const

bool	has_pragma () const

void	set_has_pragma (bool value) const

void	set_is_isolate_unsendable (bool value) const

bool	is_isolate_unsendable () const

void	set_is_isolate_unsendable_due_to_pragma (bool value) const

bool	is_isolate_unsendable_due_to_pragma () const

void	set_is_deeply_immutable (bool value) const

bool	is_deeply_immutable () const

void	set_is_future_subtype (bool value) const

bool	is_future_subtype () const

void	set_can_be_future (bool value) const

bool	can_be_future () 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

bool	IsNew () const

bool	IsOld () const

bool	InVMIsolateHeap () const

void	Print () const

Static Public Member Functions
static intptr_t	host_instance_size (ClassPtr clazz)

static intptr_t	target_instance_size (ClassPtr clazz)

static bool	is_valid_id (intptr_t value)

static intptr_t	id_offset ()

static intptr_t	num_type_arguments_offset ()

static uint32_t	Hash (ClassPtr)

static intptr_t	declaration_type_offset ()

static intptr_t	host_type_arguments_field_offset_in_words_offset ()

static intptr_t	super_type_offset ()

static bool	IsClosureClass (ClassPtr cls)

static bool	IsInFullSnapshot (ClassPtr cls)

static intptr_t	GetClassId (ClassPtr cls)

static bool	IsSubtypeOf (const Class &cls, const TypeArguments &type_arguments, Nullability nullability, const AbstractType &other, Heap::Space space, FunctionTypeMapping *function_type_equivalence=nullptr)

static intptr_t	InstanceSize ()

static uint16_t	NumNativeFieldsOf (ClassPtr clazz)

static bool	IsIsolateUnsendable (ClassPtr clazz)

template<class FakeObject , class TargetFakeObject >
static ClassPtr	New (IsolateGroup *isolate_group, bool register_class=true)

static ClassPtr	New (const Library &lib, const String &name, const Script &script, TokenPosition token_pos, bool register_class=true)

static ClassPtr	NewNativeWrapper (const Library &library, const String &name, int num_fields)

static ClassPtr	NewStringClass (intptr_t class_id, IsolateGroup *isolate_group)

static ClassPtr	NewTypedDataClass (intptr_t class_id, IsolateGroup *isolate_group)

static ClassPtr	NewTypedDataViewClass (intptr_t class_id, IsolateGroup *isolate_group)

static ClassPtr	NewUnmodifiableTypedDataViewClass (intptr_t class_id, IsolateGroup *isolate_group)

static ClassPtr	NewExternalTypedDataClass (intptr_t class_id, IsolateGroup *isolate)

static ClassPtr	NewPointerClass (intptr_t class_id, IsolateGroup *isolate_group)

static int32_t	host_instance_size_in_words (const ClassPtr cls)

static int32_t	target_instance_size_in_words (const ClassPtr cls)

static int32_t	host_next_field_offset_in_words (const ClassPtr cls)

static int32_t	target_next_field_offset_in_words (const ClassPtr cls)

static int32_t	host_type_arguments_field_offset_in_words (const ClassPtr cls)

static int32_t	target_type_arguments_field_offset_in_words (const ClassPtr cls)

static intptr_t	UnboxedFieldSizeInBytesByCid (intptr_t cid)

static bool	IsDeeplyImmutable (ClassPtr clazz)

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)

Static Public Attributes
static constexpr intptr_t	kNoTypeArguments = -1

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

static const ClassId	kClassId = kObjectCid

Friends
class	AbstractType

class	Instance

class	Object

class	Type

class	Intrinsifier

class	ProgramWalker

class	Precompiler

class	ClassFinalizer

Additional Inherited Members
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

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 1135 of file object.h.

Member Enumeration Documentation

◆ InvocationDispatcherEntry

enum dart::Class::InvocationDispatcherEntry

Enumerator
kInvocationDispatcherName
kInvocationDispatcherArgsDesc
kInvocationDispatcherFunction
kInvocationDispatcherEntrySize

Definition at line 1137 of file object.h.

                                 {
    kInvocationDispatcherName,
    kInvocationDispatcherArgsDesc,
    kInvocationDispatcherFunction,
    kInvocationDispatcherEntrySize,
  };

Member Function Documentation

◆ AddDirectImplementor()

void dart::Class::AddDirectImplementor	(	const Class &	subclass,
		bool	is_mixin
	)		const

Definition at line 5801 of file object.cc.

                                                      {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(is_implemented());
  ASSERT(!implementor.IsNull());
  GrowableObjectArray& direct_implementors =
      GrowableObjectArray::Handle(untag()->direct_implementors());
  if (direct_implementors.IsNull()) {
    direct_implementors = GrowableObjectArray::New(4, Heap::kOld);
    untag()->set_direct_implementors(direct_implementors.ptr());
  }
#if defined(DEBUG)
  // Verify that the same class is not added twice.
  // The only exception is mixins: when mixin application is transformed,
  // mixin is added to the end of interfaces list and may be duplicated:
  //   class X = A with B implements B;
  // This is rare and harmless.
  if (!is_mixin) {
    for (intptr_t i = 0; i < direct_implementors.Length(); i++) {
      ASSERT(direct_implementors.At(i) != implementor.ptr());
    }
  }
#endif
  direct_implementors.Add(implementor, Heap::kOld);
}

◆ AddDirectSubclass()

void dart::Class::AddDirectSubclass ( const Class & subclass ) const

Definition at line 5833 of file object.cc.

                                                         {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!subclass.IsNull());
  ASSERT(subclass.SuperClass() == ptr());
  // Do not keep track of the direct subclasses of class Object.
  ASSERT(!IsObjectClass());
  GrowableObjectArray& direct_subclasses =
      GrowableObjectArray::Handle(untag()->direct_subclasses());
  if (direct_subclasses.IsNull()) {
    direct_subclasses = GrowableObjectArray::New(4, Heap::kOld);
    untag()->set_direct_subclasses(direct_subclasses.ptr());
  }
#if defined(DEBUG)
  // Verify that the same class is not added twice.
  for (intptr_t i = 0; i < direct_subclasses.Length(); i++) {
    ASSERT(direct_subclasses.At(i) != subclass.ptr());
  }
#endif
  direct_subclasses.Add(subclass, Heap::kOld);
}

◆ AddField()

void dart::Class::AddField ( const Field & field ) const

Definition at line 5057 of file object.cc.

                                             {
#if defined(DEBUG)
  Thread* thread = Thread::Current();
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
#endif
  const Array& arr = Array::Handle(fields());
  const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
  new_arr.SetAt(arr.Length(), field);
  SetFields(new_arr);
}

◆ AddFields()

void dart::Class::AddFields ( const GrowableArray< const Field * > & fields ) const

Definition at line 5068 of file object.cc.

                                                                         {
#if defined(DEBUG)
  Thread* thread = Thread::Current();
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
#endif
  const intptr_t num_new_fields = new_fields.length();
  if (num_new_fields == 0) return;
  const Array& arr = Array::Handle(fields());
  const intptr_t num_old_fields = arr.Length();
  const Array& new_arr = Array::Handle(
      Array::Grow(arr, num_old_fields + num_new_fields, Heap::kOld));
  for (intptr_t i = 0; i < num_new_fields; i++) {
    new_arr.SetAt(i + num_old_fields, *new_fields.At(i));
  }
  SetFields(new_arr);
}

◆ AddFunction()

void dart::Class::AddFunction ( const Function & function ) const

Definition at line 3346 of file object.cc.

                                                      {
#if defined(DEBUG)
  Thread* thread = Thread::Current();
  ASSERT(thread->IsDartMutatorThread());
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!is_finalized() ||
         FunctionType::Handle(function.signature()).IsFinalized());
#endif
  const Array& arr = Array::Handle(functions());
  const Array& new_array =
      Array::Handle(Array::Grow(arr, arr.Length() + 1, Heap::kOld));
  new_array.SetAt(arr.Length(), function);
  set_functions(new_array);
  // Add to hash table, if any.
  const intptr_t new_len = new_array.Length();
  if (new_len == kFunctionLookupHashThreshold) {
    // Transition to using hash table.
    SetFunctions(new_array);
  } else if (new_len > kFunctionLookupHashThreshold) {
    ClassFunctionsSet set(untag()->functions_hash_table());
    set.Insert(function);
    untag()->set_functions_hash_table(set.Release().ptr());
  }
}

◆ AddInvocationDispatcher()

void dart::Class::AddInvocationDispatcher	(	const String &	target_name,
		const Array &	args_desc,
		const Function &	dispatcher
	)		const

Definition at line 3881 of file object.cc.

                                                                      {
  auto thread = Thread::Current();
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
 
  ASSERT(target_name.ptr() == dispatcher.name());
 
  DispatcherSet dispatchers(invocation_dispatcher_cache() ==
                                    Array::empty_array().ptr()
                                ? HashTables::New<DispatcherSet>(4, Heap::kOld)
                                : invocation_dispatcher_cache());
  dispatchers.Insert(dispatcher);
  set_invocation_dispatcher_cache(dispatchers.Release());
}

◆ allocation_stub()

CodePtr dart::Class::allocation_stub ( ) const

inline

Definition at line 1802 of file object.h.

1802{ return untag()->allocation_stub(); }

◆ can_be_future()

bool dart::Class::can_be_future ( ) const

inline

Definition at line 2178 of file object.h.

2178{ return CanBeFutureBit::decode(state_bits()); }

dart::BitField< uint32_t, bool, kCanBeFutureBit, 1 >::decode

static constexpr bool decode(uint32_t value)

Definition bitfield.h:173

◆ CheckReload()

void dart::Class::CheckReload	(	const Class &	replacement,
		ProgramReloadContext *	context
	)		const

Definition at line 477 of file object_reload.cc.

                                                             {
  ASSERT(ProgramReloadContext::IsSameClass(*this, replacement));
 
  if (!is_declaration_loaded()) {
    // The old class hasn't been used in any meaningful way, so the VM is okay
    // with any change.
    return;
  }
 
  // Ensure is_enum_class etc have been set.
  replacement.EnsureDeclarationLoaded();
 
  // Class cannot change enum property.
  if (is_enum_class() != replacement.is_enum_class()) {
    context->group_reload_context()->AddReasonForCancelling(
        new (context->zone())
            EnumClassConflict(context->zone(), *this, replacement));
    return;
  }
 
  if (is_finalized()) {
    // Make sure the declaration types parameter count matches for the two
    // classes.
    // ex. class A<int,B> {} cannot be replace with class A<B> {}.
    auto group_context = context->group_reload_context();
    if (NumTypeParameters() != replacement.NumTypeParameters()) {
      group_context->AddReasonForCancelling(
          new (context->zone())
              TypeParametersChanged(context->zone(), *this, replacement));
      return;
    }
  }
 
  if (is_finalized() || is_allocate_finalized()) {
    auto thread = Thread::Current();
 
    // Ensure the replacement class is also finalized.
    const Error& error = Error::Handle(
        is_allocate_finalized() ? replacement.EnsureIsAllocateFinalized(thread)
                                : replacement.EnsureIsFinalized(thread));
    if (!error.IsNull()) {
      context->group_reload_context()->AddReasonForCancelling(
          new (context->zone())
              EnsureFinalizedError(context->zone(), *this, replacement, error));
      return;  // No reason to check other properties.
    }
    ASSERT(replacement.is_finalized());
    TIR_Print("Finalized replacement class for %s\n", ToCString());
  }
 
  if (is_deeply_immutable() != replacement.is_deeply_immutable()) {
    context->group_reload_context()->AddReasonForCancelling(
        new (context->zone())
            DeeplyImmutableChange(context->zone(), *this, replacement));
    return;  // No reason to check other properties.
  }
 
  if (is_finalized() && is_const() && (constants() != Array::null()) &&
      (Array::LengthOf(constants()) > 0)) {
    // Consts can't become non-consts.
    if (!replacement.is_const()) {
      context->group_reload_context()->AddReasonForCancelling(
          new (context->zone())
              ConstToNonConstClass(context->zone(), *this, replacement));
      return;
    }
 
    // Consts can't lose fields.
    bool field_removed = false;
    const Array& old_fields = Array::Handle(
        OffsetToFieldMap(IsolateGroup::Current()->heap_walk_class_table()));
    const Array& new_fields = Array::Handle(replacement.OffsetToFieldMap());
    if (new_fields.Length() < old_fields.Length()) {
      field_removed = true;
    } else {
      Field& old_field = Field::Handle();
      Field& new_field = Field::Handle();
      String& old_name = String::Handle();
      String& new_name = String::Handle();
      for (intptr_t i = 0, n = old_fields.Length(); i < n; i++) {
        old_field ^= old_fields.At(i);
        new_field ^= new_fields.At(i);
        if (old_field.IsNull()) {
          continue;
        }
        if (new_field.IsNull()) {
          field_removed = true;
          break;
        }
        old_name = old_field.name();
        new_name = new_field.name();
        if (!old_name.Equals(new_name)) {
          field_removed = true;
          break;
        }
      }
    }
    if (field_removed) {
      context->group_reload_context()->AddReasonForCancelling(
          new (context->zone())
              ConstClassFieldRemoved(context->zone(), *this, replacement));
      return;
    }
  }
 
  // Native field count cannot change.
  if (num_native_fields() != replacement.num_native_fields()) {
    context->group_reload_context()->AddReasonForCancelling(
        new (context->zone())
            NativeFieldsConflict(context->zone(), *this, replacement));
    return;
  }
 
  // Just checking.
  ASSERT(is_enum_class() == replacement.is_enum_class());
  ASSERT(num_native_fields() == replacement.num_native_fields());
 
  if (is_finalized()) {
    if (!CanReloadFinalized(replacement, context)) return;
  }
  if (is_prefinalized()) {
    if (!CanReloadPreFinalized(replacement, context)) return;
  }
  TIR_Print("Class `%s` can be reloaded (%" Pd " and %" Pd ")\n", ToCString(),
            id(), replacement.id());
}

◆ class_loading_state()

UntaggedClass::ClassLoadingState dart::Class::class_loading_state ( ) const

inline

Definition at line 1701 of file object.h.

                                                             {
    return ClassLoadingBits::decode(state_bits());
  }

◆ constants()

ArrayPtr dart::Class::constants ( ) const

Definition at line 5861 of file object.cc.

                                {
  return untag()->constants();
}

◆ CopyCanonicalConstants()

void dart::Class::CopyCanonicalConstants ( const Class & old_cls ) const

Definition at line 229 of file object_reload.cc.

                                                             {
#if defined(DEBUG)
  {
    // Class has no canonical constants allocated.
    const Array& my_constants = Array::Handle(constants());
    ASSERT(my_constants.IsNull() || my_constants.Length() == 0);
  }
#endif  // defined(DEBUG).
  // Copy old constants into new class.
  const Array& old_constants = Array::Handle(old_cls.constants());
  if (old_constants.IsNull() || old_constants.Length() == 0) {
    return;
  }
  TIR_Print("Copied %" Pd " canonical constants for class `%s`\n",
            old_constants.Length(), ToCString());
  set_constants(old_constants);
}

◆ CopyDeclarationType()

void dart::Class::CopyDeclarationType ( const Class & old_cls ) const

Definition at line 247 of file object_reload.cc.

                                                          {
  const Type& old_declaration_type = Type::Handle(old_cls.declaration_type());
  if (old_declaration_type.IsNull()) {
    return;
  }
  set_declaration_type(old_declaration_type);
}

◆ CopyStaticFieldValues()

void dart::Class::CopyStaticFieldValues	(	ProgramReloadContext *	reload_context,
		const Class &	old_cls
	)		const

Definition at line 194 of file object_reload.cc.

                                                              {
  const Array& old_field_list = Array::Handle(old_cls.fields());
  Field& old_field = Field::Handle();
  String& old_name = String::Handle();
 
  const Array& field_list = Array::Handle(fields());
  Field& field = Field::Handle();
  String& name = String::Handle();
 
  for (intptr_t i = 0; i < field_list.Length(); i++) {
    field = Field::RawCast(field_list.At(i));
    name = field.name();
    // Find the corresponding old field, if it exists, and migrate
    // over the field value.
    for (intptr_t j = 0; j < old_field_list.Length(); j++) {
      old_field = Field::RawCast(old_field_list.At(j));
      old_name = old_field.name();
      if (name.Equals(old_name)) {
        if (field.is_static()) {
          // We only copy values if requested and if the field is not a const
          // field. We let const fields be updated with a reload.
          if (!field.is_const()) {
            // Make new field point to the old field value so that both
            // old and new code see and update same value.
            reload_context->isolate_group()->FreeStaticField(field);
            field.set_field_id_unsafe(old_field.field_id());
          }
          reload_context->AddStaticFieldMapping(old_field, field);
        }
      }
    }
  }
}

◆ current_functions()

ArrayPtr dart::Class::current_functions ( ) const

inline

Definition at line 1643 of file object.h.

                                     {
    // We rely on the fact that any loads from the array are dependent loads
    // and avoid the load-acquire barrier here.
    return untag()->functions();
  }

◆ declaration_type_offset()

static intptr_t dart::Class::declaration_type_offset ( )

inlinestatic

Definition at line 1317 of file object.h.

                                            {
    return OFFSET_OF(UntaggedClass, declaration_type_);
  }

◆ DeclarationType()

TypePtr dart::Class::DeclarationType ( ) const

Definition at line 5882 of file object.cc.

                                     {
  ASSERT(is_declaration_loaded());
  if (IsNullClass()) {
    return Type::NullType();
  }
  if (IsDynamicClass()) {
    return Type::DynamicType();
  }
  if (IsVoidClass()) {
    return Type::VoidType();
  }
  if (declaration_type() != Type::null()) {
    return declaration_type();
  }
  {
    auto thread = Thread::Current();
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    if (declaration_type() != Type::null()) {
      return declaration_type();
    }
    // For efficiency, the runtimeType intrinsic returns the type cached by
    // DeclarationType without checking its nullability. Therefore, we
    // consistently cache the kNonNullable version of the type.
    // The exception is type Null which is stored as kNullable.
    TypeArguments& type_args = TypeArguments::Handle();
    const intptr_t num_type_params = NumTypeParameters();
    if (num_type_params > 0) {
      type_args = TypeArguments::New(num_type_params);
      TypeParameter& type_param = TypeParameter::Handle();
      for (intptr_t i = 0; i < num_type_params; i++) {
        type_param = TypeParameterAt(i);
        type_args.SetTypeAt(i, type_param);
      }
    }
    Type& type =
        Type::Handle(Type::New(*this, type_args, Nullability::kNonNullable));
    type ^= ClassFinalizer::FinalizeType(type);
    set_declaration_type(type);
    return type.ptr();
  }
}

◆ DefaultTypeArguments()

TypeArgumentsPtr dart::Class::DefaultTypeArguments ( Zone * zone ) const

Definition at line 3708 of file object.cc.

                                                             {
  if (type_parameters() == TypeParameters::null()) {
    return Object::empty_type_arguments().ptr();
  }
  return TypeParameters::Handle(zone, type_parameters()).defaults();
}

◆ dependent_code()

WeakArrayPtr dart::Class::dependent_code ( ) const

Definition at line 4475 of file object.cc.

                                         {
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
  return untag()->dependent_code();
}

◆ DictionaryName()

virtual StringPtr dart::Class::DictionaryName ( ) const

inlinevirtual

Reimplemented from dart::Object.

Definition at line 1272 of file object.h.

1272{ return Name(); }

dart::Class::Name

StringPtr Name() const

Definition object.cc:3038

◆ direct_implementors()

GrowableObjectArrayPtr dart::Class::direct_implementors ( ) const

inline

Definition at line 1522 of file object.h.

                                                     {
    DEBUG_ASSERT(
        IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
    return untag()->direct_implementors();
  }

◆ direct_implementors_unsafe()

GrowableObjectArrayPtr dart::Class::direct_implementors_unsafe ( ) const

inline

Definition at line 1527 of file object.h.

                                                            {
    return untag()->direct_implementors();
  }

◆ direct_subclasses()

GrowableObjectArrayPtr dart::Class::direct_subclasses ( ) const

inline

Definition at line 1539 of file object.h.

                                                   {
    DEBUG_ASSERT(
        IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
    return direct_subclasses_unsafe();
  }

◆ direct_subclasses_unsafe()

GrowableObjectArrayPtr dart::Class::direct_subclasses_unsafe ( ) const

inline

Definition at line 1544 of file object.h.

                                                          {
    return untag()->direct_subclasses();
  }

◆ DisableAllCHAOptimizedCode()

void dart::Class::DisableAllCHAOptimizedCode ( )

Definition at line 4471 of file object.cc.

                                       {
  DisableCHAOptimizedCode(Class::Handle());
}

◆ DisableAllocationStub()

void dart::Class::DisableAllocationStub ( ) const

Definition at line 5934 of file object.cc.

                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  {
    const Code& existing_stub = Code::Handle(allocation_stub());
    if (existing_stub.IsNull()) {
      return;
    }
  }
  auto thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  const Code& existing_stub = Code::Handle(allocation_stub());
  if (existing_stub.IsNull()) {
    return;
  }
  ASSERT(!existing_stub.IsDisabled());
  // Change the stub so that the next caller will regenerate the stub.
  existing_stub.DisableStubCode(NumTypeParameters() > 0);
  // Disassociate the existing stub from class.
  untag()->set_allocation_stub(Code::null());
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ DisableCHAImplementorUsers()

void dart::Class::DisableCHAImplementorUsers ( )

inline

Definition at line 1919 of file object.h.

1919{ DisableAllCHAOptimizedCode(); }

dart::Class::DisableAllCHAOptimizedCode

void DisableAllCHAOptimizedCode()

Definition object.cc:4471

◆ DisableCHAOptimizedCode()

void dart::Class::DisableCHAOptimizedCode ( const Class & subclass )

Definition at line 4457 of file object.cc.

                                                         {
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  CHACodeArray a(*this);
  if (FLAG_trace_deoptimization && a.HasCodes()) {
    if (subclass.IsNull()) {
      THR_Print("Deopt for CHA (all)\n");
    } else {
      THR_Print("Deopt for CHA (new subclass %s)\n", subclass.ToCString());
    }
  }
  a.DisableCode(/*are_mutators_stopped=*/false);
}

◆ end_token_pos()

TokenPosition dart::Class::end_token_pos ( ) const

inline

Definition at line 1293 of file object.h.

                                      {
#if defined(DART_PRECOMPILED_RUNTIME)
    return TokenPosition::kNoSource;
#else
    return untag()->end_token_pos_;
#endif  // defined(DART_PRECOMPILED_RUNTIME)
  }

◆ EnsureDeclarationLoaded()

void dart::Class::EnsureDeclarationLoaded ( ) const

Definition at line 4968 of file object.cc.

                                          {
  if (!is_declaration_loaded()) {
#if defined(DART_PRECOMPILED_RUNTIME)
    UNREACHABLE();
#else
    FATAL("Unable to use class %s which is not loaded yet.", ToCString());
#endif
  }
}

◆ EnsureIsAllocateFinalized()

ErrorPtr dart::Class::EnsureIsAllocateFinalized ( Thread * thread ) const

Definition at line 5009 of file object.cc.

                                                              {
  ASSERT(!IsNull());
  if (is_allocate_finalized()) {
    return Error::null();
  }
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  if (is_allocate_finalized()) {
    return Error::null();
  }
  ASSERT(thread != nullptr);
  Error& error = Error::Handle(thread->zone(), EnsureIsFinalized(thread));
  if (!error.IsNull()) {
    ASSERT(thread == Thread::Current());
    if (thread->long_jump_base() != nullptr) {
      Report::LongJump(error);
      UNREACHABLE();
    }
  }
  // May be allocate-finalized recursively during EnsureIsFinalized.
  if (is_allocate_finalized()) {
    return Error::null();
  }
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  error ^= ClassFinalizer::AllocateFinalizeClass(*this);
#endif  // defined(DART_PRECOMPILED_RUNTIME)
  return error.ptr();
}

◆ EnsureIsFinalized()

ErrorPtr dart::Class::EnsureIsFinalized ( Thread * thread ) const

Definition at line 4979 of file object.cc.

                                                      {
  ASSERT(!IsNull());
  if (is_finalized()) {
    return Error::null();
  }
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
  return Error::null();
#else
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  if (is_finalized()) {
    return Error::null();
  }
  LeaveCompilerScope ncs(thread);
  ASSERT(thread != nullptr);
  const Error& error =
      Error::Handle(thread->zone(), ClassFinalizer::LoadClassMembers(*this));
  if (!error.IsNull()) {
    ASSERT(thread == Thread::Current());
    if (thread->long_jump_base() != nullptr) {
      Report::LongJump(error);
      UNREACHABLE();
    }
  }
  return error.ptr();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ EvaluateCompiledExpression()

ObjectPtr dart::Class::EvaluateCompiledExpression	(	const ExternalTypedData &	kernel_buffer,
		const Array &	type_definitions,
		const Array &	param_values,
		const TypeArguments &	type_param_values
	)		const

Definition at line 4876 of file object.cc.

                                               {
  auto thread = Thread::Current();
  const auto& library = Library::Handle(thread->zone(), this->library());
  return Instance::EvaluateCompiledExpression(
      thread, Instance::null_object(), library, *this, kernel_buffer,
      type_definitions, arguments, type_arguments);
}

◆ FieldFromIndex()

FieldPtr dart::Class::FieldFromIndex ( intptr_t idx ) const

Definition at line 5106 of file object.cc.

                                                 {
  Array& fields = Array::Handle(this->fields());
  if ((idx < 0) || (idx >= fields.Length())) {
    return Field::null();
  }
  return Field::RawCast(fields.At(idx));
}

◆ fields()

ArrayPtr dart::Class::fields ( ) const

inline

Definition at line 1617 of file object.h.

                          {
    // We rely on the fact that any loads from the array are dependent loads
    // and avoid the load-acquire barrier here.
    return untag()->fields();
  }

◆ Finalize()

void dart::Class::Finalize ( ) const

Definition at line 4362 of file object.cc.

                           {
  auto thread = Thread::Current();
  auto isolate_group = thread->isolate_group();
  ASSERT(!thread->isolate_group()->all_classes_finalized());
  ASSERT(!is_finalized());
  // Prefinalized classes have a VM internal representation and no Dart fields.
  // Their instance size  is precomputed and field offsets are known.
  if (!is_prefinalized()) {
    // Compute offsets of instance fields, instance size and bitmap for unboxed
    // fields.
    const auto host_bitmap = CalculateFieldOffsets();
    if (ptr() == isolate_group->class_table()->At(id())) {
      if (!ClassTable::IsTopLevelCid(id())) {
        // Unless class is top-level, which don't get instantiated,
        // sets the new size in the class table.
        isolate_group->class_table()->UpdateClassSize(id(), ptr());
        isolate_group->class_table()->SetUnboxedFieldsMapAt(id(), host_bitmap);
      }
    }
  }
 
#if defined(DEBUG)
  if (is_const()) {
    // Double-check that all fields are final (CFE should guarantee that if it
    // marks the class as having a constant constructor).
    auto Z = thread->zone();
    const auto& super_class = Class::Handle(Z, SuperClass());
    ASSERT(super_class.IsNull() || super_class.is_const());
    const auto& fields = Array::Handle(Z, this->fields());
    auto& field = Field::Handle(Z);
    for (intptr_t i = 0; i < fields.Length(); ++i) {
      field ^= fields.At(i);
      ASSERT(field.is_static() || field.is_final());
    }
  }
#endif
 
  set_is_finalized();
}

◆ FindFieldIndex()

intptr_t dart::Class::FindFieldIndex ( const Field & needle ) const

Definition at line 5085 of file object.cc.

                                                        {
  Thread* thread = Thread::Current();
  if (EnsureIsFinalized(thread) != Error::null()) {
    return -1;
  }
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_FIELD_HANDLESCOPE(thread);
  Array& fields = thread->ArrayHandle();
  Field& field = thread->FieldHandle();
  fields = this->fields();
  ASSERT(!fields.IsNull());
  for (intptr_t i = 0, n = fields.Length(); i < n; ++i) {
    field ^= fields.At(i);
    if (needle.ptr() == field.ptr()) {
      return i;
    }
  }
  // Not found.
  return -1;
}

◆ FindFunctionIndex()

intptr_t dart::Class::FindFunctionIndex ( const Function & needle ) const

Definition at line 3371 of file object.cc.

                                                              {
  Thread* thread = Thread::Current();
  if (EnsureIsFinalized(thread) != Error::null()) {
    return -1;
  }
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_FUNCTION_HANDLESCOPE(thread);
  Array& funcs = thread->ArrayHandle();
  Function& function = thread->FunctionHandle();
  funcs = current_functions();
  ASSERT(!funcs.IsNull());
  const intptr_t len = funcs.Length();
  for (intptr_t i = 0; i < len; i++) {
    function ^= funcs.At(i);
    if (needle.ptr() == function.ptr()) {
      return i;
    }
  }
  // No function found.
  return -1;
}

◆ FindImplicitClosureFunctionIndex()

intptr_t dart::Class::FindImplicitClosureFunctionIndex ( const Function & needle ) const

Definition at line 3414 of file object.cc.

                                                                             {
  Thread* thread = Thread::Current();
  if (EnsureIsFinalized(thread) != Error::null()) {
    return -1;
  }
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_FUNCTION_HANDLESCOPE(thread);
  Array& funcs = thread->ArrayHandle();
  Function& function = thread->FunctionHandle();
  funcs = current_functions();
  ASSERT(!funcs.IsNull());
  Function& implicit_closure = Function::Handle(thread->zone());
  const intptr_t len = funcs.Length();
  for (intptr_t i = 0; i < len; i++) {
    function ^= funcs.At(i);
    implicit_closure = function.implicit_closure_function();
    if (implicit_closure.IsNull()) {
      // Skip non-implicit closure functions.
      continue;
    }
    if (needle.ptr() == implicit_closure.ptr()) {
      return i;
    }
  }
  // No function found.
  return -1;
}

◆ FindInstantiationOf() [1/4]

bool dart::Class::FindInstantiationOf	(	Zone *	zone,
		const Class &	cls,
		bool	consider_only_super_classes = `false`
	)		const

inline

Definition at line 1470 of file object.h.

                                                                           {
    return FindInstantiationOf(zone, cls, /*path=*/nullptr,
                               consider_only_super_classes);
  }

◆ FindInstantiationOf() [2/4]

bool dart::Class::FindInstantiationOf	(	Zone *	zone,
		const Class &	cls,
		GrowableArray< const Type * > *	path,
		bool	consider_only_super_classes = `false`
	)		const

Definition at line 12723 of file object.cc.

                                                                        {
  ASSERT(cls.is_type_finalized());
  if (cls.ptr() == ptr()) {
    return true;  // Found instantiation.
  }
 
  Class& cls2 = Class::Handle(zone);
  Type& super = Type::Handle(zone, super_type());
  if (!super.IsNull() && !super.IsObjectType()) {
    cls2 = super.type_class();
    if (path != nullptr) {
      path->Add(&super);
    }
    if (cls2.FindInstantiationOf(zone, cls, path,
                                 consider_only_super_classes)) {
      return true;  // Found instantiation.
    }
    if (path != nullptr) {
      path->RemoveLast();
    }
  }
 
  if (!consider_only_super_classes) {
    Array& super_interfaces = Array::Handle(zone, interfaces());
    for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
      super ^= super_interfaces.At(i);
      cls2 = super.type_class();
      if (path != nullptr) {
        path->Add(&super);
      }
      if (cls2.FindInstantiationOf(zone, cls, path)) {
        return true;  // Found instantiation.
      }
      if (path != nullptr) {
        path->RemoveLast();
      }
    }
  }
 
  return false;  // Not found.
}

◆ FindInstantiationOf() [3/4]

bool dart::Class::FindInstantiationOf	(	Zone *	zone,
		const Type &	type,
		bool	consider_only_super_classes = `false`
	)		const

inline

Definition at line 1493 of file object.h.

                                                                           {
    return FindInstantiationOf(zone, type, /*path=*/nullptr,
                               consider_only_super_classes);
  }

◆ FindInstantiationOf() [4/4]

bool dart::Class::FindInstantiationOf	(	Zone *	zone,
		const Type &	type,
		GrowableArray< const Type * > *	path,
		bool	consider_only_super_classes = `false`
	)		const

Definition at line 12768 of file object.cc.

                                                                        {
  return FindInstantiationOf(zone, Class::Handle(zone, type.type_class()), path,
                             consider_only_super_classes);
}

◆ FindInvocationDispatcherFunctionIndex()

intptr_t dart::Class::FindInvocationDispatcherFunctionIndex ( const Function & needle ) const

Definition at line 3442 of file object.cc.

                                  {
  Thread* thread = Thread::Current();
  if (EnsureIsFinalized(thread) != Error::null()) {
    return -1;
  }
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Array& funcs = thread->ArrayHandle();
  Object& object = thread->ObjectHandle();
  funcs = invocation_dispatcher_cache();
  ASSERT(!funcs.IsNull());
  const intptr_t len = funcs.Length();
  for (intptr_t i = 0; i < len; i++) {
    object = funcs.At(i);
    // The invocation_dispatcher_cache is a table with some entries that
    // are functions.
    if (object.IsFunction()) {
      if (Function::Cast(object).ptr() == needle.ptr()) {
        return i;
      }
    }
  }
  // No function found.
  return -1;
}

◆ FunctionFromIndex()

FunctionPtr dart::Class::FunctionFromIndex ( intptr_t idx ) const

Definition at line 3393 of file object.cc.

                                                       {
  const Array& funcs = Array::Handle(current_functions());
  if ((idx < 0) || (idx >= funcs.Length())) {
    return Function::null();
  }
  Function& func = Function::Handle();
  func ^= funcs.At(idx);
  ASSERT(!func.IsNull());
  return func.ptr();
}

◆ functions()

ArrayPtr dart::Class::functions ( ) const

inline

Definition at line 1648 of file object.h.

                             {
    DEBUG_ASSERT(
        IsolateGroup::Current()->program_lock()->IsCurrentThreadReader());
    return current_functions();
  }

◆ GetClassId()

static intptr_t dart::Class::GetClassId ( ClassPtr cls )

inlinestatic

Definition at line 1593 of file object.h.

                                           {
    NoSafepointScope no_safepoint;
    return cls->untag()->id_;
  }

◆ GetDeclarationInstanceTypeArguments()

TypeArgumentsPtr dart::Class::GetDeclarationInstanceTypeArguments ( ) const

Definition at line 3526 of file object.cc.

                                                                  {
  const intptr_t num_type_arguments = NumTypeArguments();
  if (num_type_arguments == 0) {
    return TypeArguments::null();
  }
  if (declaration_instance_type_arguments() != TypeArguments::null()) {
    return declaration_instance_type_arguments();
  }
  Thread* thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  if (declaration_instance_type_arguments() != TypeArguments::null()) {
    return declaration_instance_type_arguments();
  }
  Zone* zone = thread->zone();
  auto& args = TypeArguments::Handle(zone);
  auto& type = AbstractType::Handle(zone);
  const intptr_t num_type_parameters = NumTypeParameters(thread);
  if (num_type_arguments == num_type_parameters) {
    type = DeclarationType();
    args = Type::Cast(type).arguments();
  } else {
    type = super_type();
    const auto& super_args = TypeArguments::Handle(
        zone, Type::Cast(type).GetInstanceTypeArguments(thread));
    if ((num_type_parameters == 0) ||
        (!super_args.IsNull() && (super_args.Length() == num_type_arguments))) {
      args = super_args.ptr();
    } else {
      args = TypeArguments::New(num_type_arguments);
      const intptr_t offset = num_type_arguments - num_type_parameters;
      for (intptr_t i = 0; i < offset; ++i) {
        type = super_args.TypeAtNullSafe(i);
        args.SetTypeAt(i, type);
      }
      type = DeclarationType();
      const auto& decl_args =
          TypeArguments::Handle(zone, Type::Cast(type).arguments());
      for (intptr_t i = 0; i < num_type_parameters; ++i) {
        type = decl_args.TypeAt(i);
        args.SetTypeAt(offset + i, type);
      }
    }
  }
  args = args.Canonicalize(thread);
  set_declaration_instance_type_arguments(args);
  return args.ptr();
}

◆ GetInstanceTypeArguments()

TypeArgumentsPtr dart::Class::GetInstanceTypeArguments	(	Thread *	thread,
		const TypeArguments &	type_arguments,
		bool	canonicalize = `true`
	)		const

Definition at line 3574 of file object.cc.

                             {
  const intptr_t num_type_arguments = NumTypeArguments();
  if (num_type_arguments == 0) {
    return TypeArguments::null();
  }
  Zone* zone = thread->zone();
  auto& args = TypeArguments::Handle(zone);
  const intptr_t num_type_parameters = NumTypeParameters(thread);
  ASSERT(type_arguments.IsNull() ||
         type_arguments.Length() == num_type_parameters);
  if (num_type_arguments == num_type_parameters) {
    args = type_arguments.ptr();
  } else {
    args = GetDeclarationInstanceTypeArguments();
    if (num_type_parameters == 0) {
      return args.ptr();
    }
    args = args.InstantiateFrom(
        TypeArguments::Handle(
            zone, type_arguments.ToInstantiatorTypeArguments(thread, *this)),
        Object::null_type_arguments(), kAllFree, Heap::kOld);
  }
  if (canonicalize) {
    args = args.Canonicalize(thread);
  }
  return args.ptr();
}

◆ GetInstantiationOf() [1/2]

TypePtr dart::Class::GetInstantiationOf	(	Zone *	zone,
		const Class &	cls
	)		const

Definition at line 12776 of file object.cc.

                                                                    {
  if (ptr() == cls.ptr()) {
    return DeclarationType();
  }
  if (FindInstantiationOf(zone, cls, /*consider_only_super_classes=*/true)) {
    // Since [cls] is a superclass of [this], use [cls]'s declaration type.
    return cls.DeclarationType();
  }
  const auto& decl_type = Type::Handle(zone, DeclarationType());
  GrowableArray<const Type*> path(zone, 0);
  if (!FindInstantiationOf(zone, cls, &path)) {
    return Type::null();
  }
  Thread* thread = Thread::Current();
  ASSERT(!path.is_empty());
  auto& calculated_type = Type::Handle(zone, decl_type.ptr());
  auto& calculated_type_class =
      Class::Handle(zone, calculated_type.type_class());
  auto& calculated_type_args =
      TypeArguments::Handle(zone, calculated_type.arguments());
  calculated_type_args = calculated_type_args.ToInstantiatorTypeArguments(
      thread, calculated_type_class);
  for (auto* const type : path) {
    calculated_type ^= type->ptr();
    if (!calculated_type.IsInstantiated()) {
      calculated_type ^= calculated_type.InstantiateFrom(
          calculated_type_args, Object::null_type_arguments(), kAllFree,
          Heap::kNew);
    }
    calculated_type_class = calculated_type.type_class();
    calculated_type_args = calculated_type.arguments();
    calculated_type_args = calculated_type_args.ToInstantiatorTypeArguments(
        thread, calculated_type_class);
  }
  ASSERT_EQUAL(calculated_type.type_class_id(), cls.id());
  return calculated_type.ptr();
}

◆ GetInstantiationOf() [2/2]

TypePtr dart::Class::GetInstantiationOf	(	Zone *	zone,
		const Type &	type
	)		const

Definition at line 12814 of file object.cc.

                                                                    {
  return GetInstantiationOf(zone, Class::Handle(zone, type.type_class()));
}

◆ GetInvocationDispatcher()

FunctionPtr dart::Class::GetInvocationDispatcher	(	const String &	target_name,
		const Array &	args_desc,
		UntaggedFunction::Kind	kind,
		bool	create_if_absent
	)		const

Definition at line 3897 of file object.cc.

                                                                        {
  ASSERT(kind == UntaggedFunction::kNoSuchMethodDispatcher ||
         kind == UntaggedFunction::kInvokeFieldDispatcher ||
         kind == UntaggedFunction::kDynamicInvocationForwarder);
  auto thread = Thread::Current();
  auto Z = thread->zone();
  auto& function = Function::Handle(Z);
 
  // First we'll try to find it without using locks.
  DispatcherKey key(target_name, args_desc, kind);
  if (invocation_dispatcher_cache() != Array::empty_array().ptr()) {
    DispatcherSet dispatchers(Z, invocation_dispatcher_cache());
    function ^= dispatchers.GetOrNull(key);
    dispatchers.Release();
  }
  if (!function.IsNull() || !create_if_absent) {
    return function.ptr();
  }
 
  // If we failed to find it and possibly need to create it, use a write lock.
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  // Try to find it again & return if it was added in the meantime.
  if (invocation_dispatcher_cache() != Array::empty_array().ptr()) {
    DispatcherSet dispatchers(Z, invocation_dispatcher_cache());
    function ^= dispatchers.GetOrNull(key);
    dispatchers.Release();
  }
  if (!function.IsNull()) return function.ptr();
 
  // Otherwise create it & add it.
  function = CreateInvocationDispatcher(target_name, args_desc, kind);
  AddInvocationDispatcher(target_name, args_desc, function);
  return function.ptr();
}

◆ GetRecordFieldGetter()

FunctionPtr dart::Class::GetRecordFieldGetter ( const String & getter_name ) const

Definition at line 4128 of file object.cc.

                                                                       {
  ASSERT(IsRecordClass());
  ASSERT(Field::IsGetterName(getter_name));
  Thread* thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  Function& result = Function::Handle(thread->zone(),
                                      LookupDynamicFunctionUnsafe(getter_name));
  if (result.IsNull()) {
    result = CreateRecordFieldGetter(getter_name);
  }
  ASSERT(result.kind() == UntaggedFunction::kRecordFieldGetter);
  return result.ptr();
}

◆ has_pragma()

bool dart::Class::has_pragma ( ) const

inline

Definition at line 2149 of file object.h.

2149{ return HasPragmaBit::decode(state_bits()); }

◆ HasCompressedPointers()

bool dart::Class::HasCompressedPointers ( ) const

Definition at line 3007 of file object.cc.

                                        {
  const intptr_t cid = id();
  switch (cid) {
    case kByteBufferCid:
      return ByteBuffer::ContainsCompressedPointers();
#define HANDLE_CASE(clazz)                                                     \
  case k##clazz##Cid:                                                          \
    return dart::clazz::ContainsCompressedPointers();
      CLASS_LIST(HANDLE_CASE)
#undef HANDLE_CASE
#define HANDLE_CASE(clazz)                                                     \
  case kTypedData##clazz##Cid:                                                 \
    return dart::TypedData::ContainsCompressedPointers();                      \
  case kTypedData##clazz##ViewCid:                                             \
  case kUnmodifiableTypedData##clazz##ViewCid:                                 \
    return dart::TypedDataView::ContainsCompressedPointers();                  \
  case kExternalTypedData##clazz##Cid:                                         \
    return dart::ExternalTypedData::ContainsCompressedPointers();
      CLASS_LIST_TYPED_DATA(HANDLE_CASE)
#undef HANDLE_CASE
    default:
      if (cid >= kNumPredefinedCids) {
        return dart::Instance::ContainsCompressedPointers();
      }
  }
  FATAL("Unsupported class for compressed pointers translation: %s (id=%" Pd
        ", kNumPredefinedCids=%" Pd ")\n",
        ToCString(), cid, kNumPredefinedCids);
  return false;
}

◆ Hash() [1/2]

uint32_t dart::Class::Hash ( ) const

Definition at line 5652 of file object.cc.

                           {
  return Class::Hash(ptr());
}

◆ Hash() [2/2]

uint32_t dart::Class::Hash ( ClassPtr obj )

static

Definition at line 5655 of file object.cc.

                                 {
  return String::HashRawSymbol(obj.untag()->name());
}

◆ HasInstanceFields()

bool dart::Class::HasInstanceFields ( ) const

Definition at line 3261 of file object.cc.

                                    {
  const Array& field_array = Array::Handle(fields());
  Field& field = Field::Handle();
  for (intptr_t i = 0; i < field_array.Length(); ++i) {
    field ^= field_array.At(i);
    if (!field.is_static()) {
      return true;
    }
  }
  return false;
}

◆ host_instance_size() [1/2]

intptr_t dart::Class::host_instance_size ( ) const

inline

Definition at line 1145 of file object.h.

                                      {
    ASSERT(is_finalized() || is_prefinalized());
    return (untag()->host_instance_size_in_words_ * kCompressedWordSize);
  }

◆ host_instance_size() [2/2]

static intptr_t dart::Class::host_instance_size ( ClassPtr clazz )

inlinestatic

Definition at line 1158 of file object.h.

                                                     {
    return (clazz->untag()->host_instance_size_in_words_ * kCompressedWordSize);
  }

◆ host_instance_size_in_words()

static int32_t dart::Class::host_instance_size_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1945 of file object.h.

                                                                 {
    return cls->untag()->host_instance_size_in_words_;
  }

◆ host_next_field_offset()

intptr_t dart::Class::host_next_field_offset ( ) const

inline

Definition at line 1192 of file object.h.

                                          {
    return untag()->host_next_field_offset_in_words_ * kCompressedWordSize;
  }

◆ host_next_field_offset_in_words()

static int32_t dart::Class::host_next_field_offset_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1957 of file object.h.

                                                                     {
    return cls->untag()->host_next_field_offset_in_words_;
  }

◆ host_type_arguments_field_offset()

intptr_t dart::Class::host_type_arguments_field_offset ( ) const

inline

Definition at line 1377 of file object.h.

                                                    {
    ASSERT(is_type_finalized() || is_prefinalized());
    if (untag()->host_type_arguments_field_offset_in_words_ ==
        kNoTypeArguments) {
      return kNoTypeArguments;
    }
    return untag()->host_type_arguments_field_offset_in_words_ *
           kCompressedWordSize;
  }

◆ host_type_arguments_field_offset_in_words()

static int32_t dart::Class::host_type_arguments_field_offset_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1969 of file object.h.

                                                                               {
    return cls->untag()->host_type_arguments_field_offset_in_words_;
  }

◆ host_type_arguments_field_offset_in_words_offset()

static intptr_t dart::Class::host_type_arguments_field_offset_in_words_offset ( )

inlinestatic

Definition at line 1428 of file object.h.

                                                                     {
    return OFFSET_OF(UntaggedClass, host_type_arguments_field_offset_in_words_);
  }

◆ id()

intptr_t dart::Class::id ( ) const

inline

Definition at line 1235 of file object.h.

1235{ return untag()->id_; }

◆ id_offset()

static intptr_t dart::Class::id_offset ( )

inlinestatic

Definition at line 1240 of file object.h.

1240{ return OFFSET_OF(UntaggedClass, id_); }

◆ implementor_cid()

intptr_t dart::Class::implementor_cid ( ) const

inline

Definition at line 1247 of file object.h.

1247{ return untag()->implementor_cid_; }

◆ ImplicitClosureFunctionFromIndex()

FunctionPtr dart::Class::ImplicitClosureFunctionFromIndex ( intptr_t idx ) const

Definition at line 3404 of file object.cc.

                                                                      {
  Function& func = Function::Handle(FunctionFromIndex(idx));
  if (func.IsNull() || !func.HasImplicitClosureFunction()) {
    return Function::null();
  }
  func = func.ImplicitClosureFunction();
  ASSERT(!func.IsNull());
  return func.ptr();
}

◆ InjectCIDFields()

bool dart::Class::InjectCIDFields ( ) const

Definition at line 5114 of file object.cc.

                                  {
  if (library() != Library::InternalLibrary() ||
      Name() != Symbols::ClassID().ptr()) {
    return false;
  }
 
  auto thread = Thread::Current();
  auto isolate_group = thread->isolate_group();
  auto zone = thread->zone();
  Field& field = Field::Handle(zone);
  Smi& value = Smi::Handle(zone);
  String& field_name = String::Handle(zone);
 
  // clang-format off
  static const struct {
    const char* const field_name;
    const intptr_t cid;
  } cid_fields[] = {
#define CLASS_LIST_WITH_NULL(V)                                                \
    V(Null)                                                                    \
    CLASS_LIST_NO_OBJECT(V)
#define ADD_SET_FIELD(clazz)                                                   \
    {"cid" #clazz, k##clazz##Cid},
    CLASS_LIST_WITH_NULL(ADD_SET_FIELD)
#undef ADD_SET_FIELD
#undef CLASS_LIST_WITH_NULL
#define ADD_SET_FIELD(clazz)                                                   \
    {"cid" #clazz, kTypedData##clazz##Cid},                                    \
    {"cid" #clazz "View", kTypedData##clazz##ViewCid},                         \
    {"cidExternal" #clazz, kExternalTypedData##clazz##Cid},                    \
    {"cidUnmodifiable" #clazz "View", kUnmodifiableTypedData##clazz##ViewCid}, \
    CLASS_LIST_TYPED_DATA(ADD_SET_FIELD)
#undef ADD_SET_FIELD
    // Used in const hashing to determine whether we're dealing with a
    // user-defined const. See lib/_internal/vm/lib/compact_hash.dart.
    {"numPredefinedCids", kNumPredefinedCids},
  };
  // clang-format on
 
  const AbstractType& field_type = Type::Handle(zone, Type::IntType());
  for (size_t i = 0; i < ARRAY_SIZE(cid_fields); i++) {
    field_name = Symbols::New(thread, cid_fields[i].field_name);
    field = Field::New(field_name, /* is_static = */ true,
                       /* is_final = */ false,
                       /* is_const = */ true,
                       /* is_reflectable = */ false,
                       /* is_late = */ false, *this, field_type,
                       TokenPosition::kMinSource, TokenPosition::kMinSource);
    value = Smi::New(cid_fields[i].cid);
    isolate_group->RegisterStaticField(field, value);
    AddField(field);
  }
 
  return true;
}

◆ InsertCanonicalConstant()

InstancePtr dart::Class::InsertCanonicalConstant	(	Zone *	zone,
		const Instance &	constant
	)		const

Definition at line 6540 of file object.cc.

                                                                           {
  ASSERT(constant.IsCanonical());
  ASSERT(this->ptr() == constant.clazz());
  Instance& canonical_value = Instance::Handle(zone);
  if (this->constants() == Array::null()) {
    CanonicalInstancesSet constants(
        HashTables::New<CanonicalInstancesSet>(128, Heap::kOld));
    canonical_value ^= constants.InsertNewOrGet(CanonicalInstanceKey(constant));
    this->set_constants(constants.Release());
  } else {
    CanonicalInstancesSet constants(Thread::Current()->zone(),
                                    this->constants());
    canonical_value ^= constants.InsertNewOrGet(CanonicalInstanceKey(constant));
    this->set_constants(constants.Release());
  }
  return canonical_value.ptr();
}

◆ InstanceSize()

static intptr_t dart::Class::InstanceSize ( )

inlinestatic

Definition at line 1687 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedClass));
  }

◆ interfaces()

ArrayPtr dart::Class::interfaces ( ) const

inline

Definition at line 1449 of file object.h.

                              {
    ASSERT(is_declaration_loaded());
    return untag()->interfaces();
  }

◆ InvocationDispatcherFunctionFromIndex()

FunctionPtr dart::Class::InvocationDispatcherFunctionFromIndex ( intptr_t idx ) const

Definition at line 3469 of file object.cc.

                                                                           {
  Thread* thread = Thread::Current();
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  Array& dispatcher_cache = thread->ArrayHandle();
  Object& object = thread->ObjectHandle();
  dispatcher_cache = invocation_dispatcher_cache();
  object = dispatcher_cache.At(idx);
  if (!object.IsFunction()) {
    return Function::null();
  }
  return Function::Cast(object).ptr();
}

◆ Invoke()

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

Definition at line 4739 of file object.cc.

                                                        {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  CHECK_ERROR(EnsureIsFinalized(thread));
 
  // We don't pass any explicit type arguments, which will be understood as
  // using dynamic for any function type arguments by lower layers.
  const int kTypeArgsLen = 0;
  const Array& args_descriptor_array = Array::Handle(
      zone, ArgumentsDescriptor::NewBoxed(kTypeArgsLen, args.Length(),
                                          arg_names, Heap::kNew));
  ArgumentsDescriptor args_descriptor(args_descriptor_array);
 
  Function& function =
      Function::Handle(zone, LookupStaticFunction(function_name));
 
  if (!function.IsNull() && check_is_entrypoint) {
    CHECK_ERROR(function.VerifyCallEntryPoint());
  }
 
  if (function.IsNull()) {
    // Didn't find a method: try to find a getter and invoke call on its result.
    const Object& getter_result = Object::Handle(
        zone, InvokeGetter(function_name, false, respect_reflectable,
                           check_is_entrypoint));
    if (getter_result.ptr() != Object::sentinel().ptr()) {
      if (check_is_entrypoint) {
        CHECK_ERROR(EntryPointFieldInvocationError(function_name));
      }
      const auto& call_args_descriptor_array = Array::Handle(
          zone, ArgumentsDescriptor::NewBoxed(args_descriptor.TypeArgsLen(),
                                              args_descriptor.Count() + 1,
                                              arg_names, Heap::kNew));
      const auto& call_args = Array::Handle(
          zone,
          CreateCallableArgumentsFromStatic(zone, Instance::Cast(getter_result),
                                            args, arg_names, args_descriptor));
      return DartEntry::InvokeClosure(thread, call_args,
                                      call_args_descriptor_array);
    }
  }
 
  if (function.IsNull() ||
      !function.AreValidArguments(args_descriptor, nullptr) ||
      (respect_reflectable && !function.is_reflectable())) {
    return ThrowNoSuchMethod(
        AbstractType::Handle(zone, RareType()), function_name, args, arg_names,
        InvocationMirror::kStatic, InvocationMirror::kMethod);
  }
  // This is a static function, so we pass an empty instantiator tav.
  ASSERT(function.is_static());
  ObjectPtr type_error = function.DoArgumentTypesMatch(
      args, args_descriptor, Object::empty_type_arguments());
  if (type_error != Error::null()) {
    return type_error;
  }
  return DartEntry::InvokeFunction(function, args, args_descriptor_array);
}

◆ InvokeGetter()

ObjectPtr dart::Class::InvokeGetter	(	const String &	selector,
		bool	throw_nsm_if_absent,
		bool	respect_reflectable = `true`,
		bool	check_is_entrypoint = `false`
	)		const

Definition at line 4572 of file object.cc.

                                                              {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  CHECK_ERROR(EnsureIsFinalized(thread));
 
  // Note static fields do not have implicit getters.
  const Field& field = Field::Handle(zone, LookupStaticField(getter_name));
 
  if (!field.IsNull() && check_is_entrypoint) {
    CHECK_ERROR(field.VerifyEntryPoint(EntryPointPragma::kGetterOnly));
  }
 
  if (field.IsNull() || field.IsUninitialized()) {
    const String& internal_getter_name =
        String::Handle(zone, Field::GetterName(getter_name));
    Function& getter =
        Function::Handle(zone, LookupStaticFunction(internal_getter_name));
 
    if (field.IsNull() && !getter.IsNull() && check_is_entrypoint) {
      CHECK_ERROR(getter.VerifyCallEntryPoint());
    }
 
    if (getter.IsNull() || (respect_reflectable && !getter.is_reflectable())) {
      if (getter.IsNull()) {
        getter = LookupStaticFunction(getter_name);
        if (!getter.IsNull()) {
          if (check_is_entrypoint) {
            CHECK_ERROR(getter.VerifyClosurizedEntryPoint());
          }
          if (getter.SafeToClosurize()) {
            // Looking for a getter but found a regular method: closurize it.
            const Function& closure_function =
                Function::Handle(zone, getter.ImplicitClosureFunction());
            return closure_function.ImplicitStaticClosure();
          }
        }
      }
      if (throw_nsm_if_absent) {
        return ThrowNoSuchMethod(
            AbstractType::Handle(zone, RareType()), getter_name,
            Object::null_array(), Object::null_array(),
            InvocationMirror::kStatic, InvocationMirror::kGetter);
      }
      // Fall through case: Indicate that we didn't find any function or field
      // using a special null instance. This is different from a field being
      // null. Callers make sure that this null does not leak into Dartland.
      return Object::sentinel().ptr();
    }
 
    // Invoke the getter and return the result.
    return DartEntry::InvokeFunction(getter, Object::empty_array());
  }
 
  return field.StaticValue();
}

◆ InvokeSetter()

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

Definition at line 4632 of file object.cc.

                                                              {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  CHECK_ERROR(EnsureIsFinalized(thread));
 
  // Check for real fields and user-defined setters.
  const Field& field = Field::Handle(zone, LookupStaticField(setter_name));
  const String& internal_setter_name =
      String::Handle(zone, Field::SetterName(setter_name));
 
  if (!field.IsNull() && check_is_entrypoint) {
    CHECK_ERROR(field.VerifyEntryPoint(EntryPointPragma::kSetterOnly));
  }
 
  AbstractType& parameter_type = AbstractType::Handle(zone);
  if (field.IsNull()) {
    const Function& setter =
        Function::Handle(zone, LookupStaticFunction(internal_setter_name));
    if (!setter.IsNull() && check_is_entrypoint) {
      CHECK_ERROR(setter.VerifyCallEntryPoint());
    }
    const int kNumArgs = 1;
    const Array& args = Array::Handle(zone, Array::New(kNumArgs));
    args.SetAt(0, value);
    if (setter.IsNull() || (respect_reflectable && !setter.is_reflectable())) {
      return ThrowNoSuchMethod(AbstractType::Handle(zone, RareType()),
                               internal_setter_name, args, Object::null_array(),
                               InvocationMirror::kStatic,
                               InvocationMirror::kSetter);
    }
    parameter_type = setter.ParameterTypeAt(0);
    if (!value.RuntimeTypeIsSubtypeOf(parameter_type,
                                      Object::null_type_arguments(),
                                      Object::null_type_arguments())) {
      const String& argument_name =
          String::Handle(zone, setter.ParameterNameAt(0));
      return ThrowTypeError(setter.token_pos(), value, parameter_type,
                            argument_name);
    }
    // Invoke the setter and return the result.
    return DartEntry::InvokeFunction(setter, args);
  }
 
  if (field.is_final() || (respect_reflectable && !field.is_reflectable())) {
    const int kNumArgs = 1;
    const Array& args = Array::Handle(zone, Array::New(kNumArgs));
    args.SetAt(0, value);
    return ThrowNoSuchMethod(AbstractType::Handle(zone, RareType()),
                             internal_setter_name, args, Object::null_array(),
                             InvocationMirror::kStatic,
                             InvocationMirror::kSetter);
  }
 
  parameter_type = field.type();
  if (!value.RuntimeTypeIsSubtypeOf(parameter_type,
                                    Object::null_type_arguments(),
                                    Object::null_type_arguments())) {
    const String& argument_name = String::Handle(zone, field.name());
    return ThrowTypeError(field.token_pos(), value, parameter_type,
                          argument_name);
  }
  field.SetStaticValue(value);
  return value.ptr();
}

◆ is_abstract()

bool dart::Class::is_abstract ( ) const

inline

Definition at line 1698 of file object.h.

1698{ return AbstractBit::decode(state_bits()); }

◆ is_allocate_finalized()

bool dart::Class::is_allocate_finalized ( ) const

inline

Definition at line 1734 of file object.h.

                                     {
    return ClassFinalizedBits::decode(state_bits()) ==
           UntaggedClass::kAllocateFinalized;
  }

◆ is_allocated()

bool dart::Class::is_allocated ( ) const

inline

Definition at line 1783 of file object.h.

1783{ return IsAllocatedBit::decode(state_bits()); }

◆ is_base_class()

bool dart::Class::is_base_class ( ) const

inline

Definition at line 1767 of file object.h.

1767{ return BaseClassBit::decode(state_bits()); }

◆ is_const()

bool dart::Class::is_const ( ) const

inline

Definition at line 1747 of file object.h.

1747{ return ConstBit::decode(state_bits()); }

◆ is_declaration_loaded()

bool dart::Class::is_declaration_loaded ( ) const

inline

Definition at line 1705 of file object.h.

                                     {
    return class_loading_state() >= UntaggedClass::kDeclarationLoaded;
  }

◆ is_deeply_immutable()

bool dart::Class::is_deeply_immutable ( ) const

inline

Definition at line 2164 of file object.h.

                                   {
    return IsDeeplyImmutableBit::decode(state_bits());
  }

◆ is_enum_class()

bool dart::Class::is_enum_class ( ) const

inline

Definition at line 1722 of file object.h.

1722{ return EnumBit::decode(state_bits()); }

◆ is_fields_marked_nullable()

bool dart::Class::is_fields_marked_nullable ( ) const

inline

Definition at line 1778 of file object.h.

                                         {
    return FieldsMarkedNullableBit::decode(state_bits());
  }

◆ is_final()

bool dart::Class::is_final ( ) const

inline

Definition at line 1775 of file object.h.

1775{ return FinalBit::decode(state_bits()); }

◆ is_finalized()

bool dart::Class::is_finalized ( ) const

inline

Definition at line 1725 of file object.h.

                            {
    return ClassFinalizedBits::decode(state_bits()) ==
               UntaggedClass::kFinalized ||
           ClassFinalizedBits::decode(state_bits()) ==
               UntaggedClass::kAllocateFinalized;
  }

◆ is_future_subtype()

bool dart::Class::is_future_subtype ( ) const

inline

Definition at line 2172 of file object.h.

                                 {
    ASSERT(is_type_finalized());
    return IsFutureSubtypeBit::decode(state_bits());
  }

◆ is_implemented()

bool dart::Class::is_implemented ( ) const

inline

Definition at line 1694 of file object.h.

1694{ return ImplementedBit::decode(state_bits()); }

◆ is_interface_class()

bool dart::Class::is_interface_class ( ) const

inline

Definition at line 1770 of file object.h.

                                  {
    return InterfaceClassBit::decode(state_bits());
  }

◆ is_isolate_unsendable()

bool dart::Class::is_isolate_unsendable ( ) const

inline

Definition at line 2153 of file object.h.

                                     {
    ASSERT(is_finalized());  // This bit is initialized in class finalizer.
    return IsIsolateUnsendableBit::decode(state_bits());
  }

◆ is_isolate_unsendable_due_to_pragma()

bool dart::Class::is_isolate_unsendable_due_to_pragma ( ) const

inline

Definition at line 2159 of file object.h.

                                                   {
    return IsIsolateUnsendableDueToPragmaBit::decode(state_bits());
  }

◆ is_loaded()

bool dart::Class::is_loaded ( ) const

inline

Definition at line 1787 of file object.h.

1787{ return IsLoadedBit::decode(state_bits()); }

◆ is_mixin_class()

bool dart::Class::is_mixin_class ( ) const

inline

Definition at line 1764 of file object.h.

1764{ return MixinClassBit::decode(state_bits()); }

◆ is_prefinalized()

bool dart::Class::is_prefinalized ( ) const

inline

Definition at line 1740 of file object.h.

                               {
    return ClassFinalizedBits::decode(state_bits()) ==
           UntaggedClass::kPreFinalized;
  }

◆ is_sealed()

bool dart::Class::is_sealed ( ) const

inline

Definition at line 1761 of file object.h.

1761{ return SealedBit::decode(state_bits()); }

◆ is_synthesized_class()

bool dart::Class::is_synthesized_class ( ) const

inline

Definition at line 1716 of file object.h.

                                    {
    return SynthesizedClassBit::decode(state_bits());
  }

◆ is_transformed_mixin_application()

bool dart::Class::is_transformed_mixin_application ( ) const

inline

Definition at line 1756 of file object.h.

                                                {
    return TransformedMixinApplicationBit::decode(state_bits());
  }

◆ is_type_finalized()

bool dart::Class::is_type_finalized ( ) const

inline

Definition at line 1711 of file object.h.

                                 {
    return class_loading_state() >= UntaggedClass::kTypeFinalized;
  }

◆ is_valid_id()

static bool dart::Class::is_valid_id ( intptr_t value )

inlinestatic

Definition at line 1232 of file object.h.

                                          {
    return UntaggedObject::ClassIdTag::is_valid(value);
  }

◆ IsClosureClass() [1/2]

bool dart::Class::IsClosureClass ( ) const

inline

Definition at line 1579 of file object.h.

1579{ return id() == kClosureCid; }

◆ IsClosureClass() [2/2]

static bool dart::Class::IsClosureClass ( ClassPtr cls )

inlinestatic

Definition at line 1580 of file object.h.

                                           {
    return GetClassId(cls) == kClosureCid;
  }

◆ IsDartFunctionClass()

bool dart::Class::IsDartFunctionClass ( ) const

Definition at line 5958 of file object.cc.

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

◆ IsDeeplyImmutable()

static bool dart::Class::IsDeeplyImmutable ( ClassPtr clazz )

inlinestatic

Definition at line 2167 of file object.h.

                                                {
    return IsDeeplyImmutableBit::decode(clazz->untag()->state_bits_);
  }

◆ IsDynamicClass()

bool dart::Class::IsDynamicClass ( ) const

inline

Definition at line 1558 of file object.h.

1558{ return id() == kDynamicCid; }

dart::kDynamicCid

@ kDynamicCid

Definition class_id.h:253

◆ IsFutureClass()

bool dart::Class::IsFutureClass ( ) const

Definition at line 5962 of file object.cc.

                                {
  // Looking up future_class in the object store would not work, because
  // this function is called during class finalization, before the object store
  // field would be initialized by InitKnownObjects().
  return (Name() == Symbols::Future().ptr()) &&
         (library() == Library::AsyncLibrary());
}

◆ IsFutureOrClass()

bool dart::Class::IsFutureOrClass ( ) const

inline

Definition at line 1576 of file object.h.

1576{ return id() == kFutureOrCid; }

◆ IsGeneric()

bool dart::Class::IsGeneric ( ) const

inline

Definition at line 1360 of file object.h.

                         {
    // If the declaration is not loaded, fall back onto NumTypeParameters.
    if (!is_declaration_loaded()) {
      return NumTypeParameters(Thread::Current()) > 0;
    }
    return type_parameters() != Object::null();
  }

◆ IsInFullSnapshot() [1/2]

bool dart::Class::IsInFullSnapshot ( ) const

Definition at line 3091 of file object.cc.

                                   {
  NoSafepointScope no_safepoint;
  return UntaggedLibrary::InFullSnapshotBit::decode(
      untag()->library()->untag()->flags_);
}

◆ IsInFullSnapshot() [2/2]

static bool dart::Class::IsInFullSnapshot ( ClassPtr cls )

inlinestatic

Definition at line 1587 of file object.h.

                                             {
    NoSafepointScope no_safepoint;
    return UntaggedLibrary::InFullSnapshotBit::decode(
        cls->untag()->library()->untag()->flags_);
  }

◆ IsIsolateUnsendable()

static bool dart::Class::IsIsolateUnsendable ( ClassPtr clazz )

inlinestatic

Definition at line 1797 of file object.h.

                                                  {
    return IsIsolateUnsendableBit::decode(clazz->untag()->state_bits_);
  }

◆ IsNeverClass()

bool dart::Class::IsNeverClass ( ) const

inline

Definition at line 1564 of file object.h.

1564{ return id() == kNeverCid; }

dart::kNeverCid

@ kNeverCid

Definition class_id.h:255

◆ IsNullClass()

bool dart::Class::IsNullClass ( ) const

inline

Definition at line 1555 of file object.h.

1555{ return id() == kNullCid; }

dart::kNullCid

@ kNullCid

Definition class_id.h:252

◆ IsObjectClass()

bool dart::Class::IsObjectClass ( ) const

inline

Definition at line 1567 of file object.h.

1567{ return id() == kInstanceCid; }

◆ IsPrivate()

bool dart::Class::IsPrivate ( ) const

Definition at line 6180 of file object.cc.

                            {
  return Library::IsPrivate(String::Handle(Name()));
}

◆ IsRecordClass()

bool dart::Class::IsRecordClass ( ) const

inline

Definition at line 1585 of file object.h.

1585{ return id() == kRecordCid; }

◆ IsSubtypeOf()

bool dart::Class::IsSubtypeOf	(	const Class &	cls,
		const TypeArguments &	type_arguments,
		Nullability	nullability,
		const AbstractType &	other,
		Heap::Space	space,
		FunctionTypeMapping *	function_type_equivalence = `nullptr`
	)

static

Definition at line 5975 of file object.cc.

                                                                        {
  TRACE_TYPE_CHECKS_VERBOSE("  Class::IsSubtypeOf(%s %s, %s)\n",
                            cls.ToCString(), type_arguments.ToCString(),
                            other.ToCString());
  // This function does not support Null, Never, dynamic, or void as type T0.
  classid_t this_cid = cls.id();
  ASSERT(this_cid != kNullCid && this_cid != kNeverCid &&
         this_cid != kDynamicCid && this_cid != kVoidCid);
  ASSERT(type_arguments.IsNull() ||
         (type_arguments.Length() >= cls.NumTypeArguments()));
  // Type T1 must have a type class (e.g. not a type param or a function type).
  ASSERT(other.HasTypeClass());
  const classid_t other_cid = other.type_class_id();
  if (other_cid == kDynamicCid || other_cid == kVoidCid) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: true (right is top)\n");
    return true;
  }
  // Left nullable:
  //   if T0 is S0? then:
  //     T0 <: T1 iff S0 <: T1 and Null <: T1
  if ((nullability == Nullability::kNullable) &&
      !Instance::NullIsAssignableTo(other)) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: false (nullability)\n");
    return false;
  }
 
  // Right Object.
  if (other_cid == kObjectCid) {
    TRACE_TYPE_CHECKS_VERBOSE("   - result: true (right is Object)\n");
    return true;
  }
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Class& other_class = Class::Handle(zone, other.type_class());
  const TypeArguments& other_type_arguments =
      TypeArguments::Handle(zone, other.arguments());
  // Use the 'this_class' object as if it was the receiver of this method, but
  // instead of recursing, reset it to the super class and loop.
  Class& this_class = Class::Handle(zone, cls.ptr());
  while (true) {
    // Apply additional subtyping rules if T0 or T1 are 'FutureOr'.
 
    // Left FutureOr:
    //   if T0 is FutureOr<S0> then:
    //     T0 <: T1 iff Future<S0> <: T1 and S0 <: T1
    if (this_cid == kFutureOrCid) {
      // Check Future<S0> <: T1.
      ObjectStore* object_store = IsolateGroup::Current()->object_store();
      const Class& future_class =
          Class::Handle(zone, object_store->future_class());
      ASSERT(!future_class.IsNull() && future_class.NumTypeParameters() == 1 &&
             this_class.NumTypeParameters() == 1);
      ASSERT(type_arguments.IsNull() || type_arguments.Length() >= 1);
      if (Class::IsSubtypeOf(future_class, type_arguments,
                             Nullability::kNonNullable, other, space,
                             function_type_equivalence)) {
        // Check S0 <: T1.
        const AbstractType& type_arg =
            AbstractType::Handle(zone, type_arguments.TypeAtNullSafe(0));
        if (type_arg.IsSubtypeOf(other, space, function_type_equivalence)) {
          TRACE_TYPE_CHECKS_VERBOSE("   - result: true (left is FutureOr)\n");
          return true;
        }
      }
    }
 
    // Right FutureOr:
    //   if T1 is FutureOr<S1> then:
    //     T0 <: T1 iff any of the following hold:
    //     either T0 <: Future<S1>
    //     or T0 <: S1
    //     or T0 is X0 and X0 has bound S0 and S0 <: T1  (checked elsewhere)
    if (other_cid == kFutureOrCid) {
      const AbstractType& other_type_arg =
          AbstractType::Handle(zone, other_type_arguments.TypeAtNullSafe(0));
      // Check if S1 is a top type.
      if (other_type_arg.IsTopTypeForSubtyping()) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: true (right is FutureOr top)\n");
        return true;
      }
      // Check T0 <: Future<S1> when T0 is Future<S0>.
      if (this_class.IsFutureClass()) {
        const AbstractType& type_arg =
            AbstractType::Handle(zone, type_arguments.TypeAtNullSafe(0));
        // If T0 is Future<S0>, then T0 <: Future<S1>, iff S0 <: S1.
        if (type_arg.IsSubtypeOf(other_type_arg, space,
                                 function_type_equivalence)) {
          TRACE_TYPE_CHECKS_VERBOSE(
              "   - result: true (left is Future, right is FutureOr)\n");
          return true;
        }
      }
      // Check T0 <: Future<S1> when T0 is FutureOr<S0> is already done.
      // Check T0 <: S1.
      if (other_type_arg.HasTypeClass() &&
          Class::IsSubtypeOf(this_class, type_arguments, nullability,
                             other_type_arg, space,
                             function_type_equivalence)) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: true (right is FutureOr, subtype of arg)\n");
        return true;
      }
    }
 
    // Check for reflexivity.
    if (this_class.ptr() == other_class.ptr()) {
      const intptr_t num_type_params = this_class.NumTypeParameters();
      if (num_type_params == 0) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: true (same non-generic class)\n");
        return true;
      }
      // Check for covariance.
      if (other_type_arguments.IsNull()) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: true (same class, dynamic type args)\n");
        return true;
      }
      const intptr_t num_type_args = this_class.NumTypeArguments();
      const intptr_t from_index = num_type_args - num_type_params;
      ASSERT(other_type_arguments.Length() == num_type_params);
      AbstractType& type = AbstractType::Handle(zone);
      AbstractType& other_type = AbstractType::Handle(zone);
      for (intptr_t i = 0; i < num_type_params; ++i) {
        type = type_arguments.TypeAtNullSafe(from_index + i);
        other_type = other_type_arguments.TypeAt(i);
        ASSERT(!type.IsNull() && !other_type.IsNull());
        if (!type.IsSubtypeOf(other_type, space, function_type_equivalence)) {
          TRACE_TYPE_CHECKS_VERBOSE(
              "   - result: false (same class, type args mismatch)\n");
          return false;
        }
      }
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: true (same class, matching type args)\n");
      return true;
    }
 
    // _Closure <: Function
    if (this_class.IsClosureClass() && other_class.IsDartFunctionClass()) {
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: true (left is closure, right is Function)\n");
      return true;
    }
 
    // Check for 'direct super type' specified in the implements clause
    // and check for transitivity at the same time.
    Array& interfaces = Array::Handle(zone, this_class.interfaces());
    Type& interface = Type::Handle(zone);
    Class& interface_class = Class::Handle(zone);
    TypeArguments& interface_args = TypeArguments::Handle(zone);
    for (intptr_t i = 0; i < interfaces.Length(); i++) {
      interface ^= interfaces.At(i);
      ASSERT(interface.IsFinalized());
      interface_class = interface.type_class();
      interface_args = interface.arguments();
      if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
        // This type class implements an interface that is parameterized with
        // generic type(s), e.g. it implements List<T>.
        // The uninstantiated type T must be instantiated using the type
        // parameters of this type before performing the type test.
        // 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,
        // after the type arguments of the super type of this type.
        // The index of the type parameters is adjusted upon finalization.
        interface_args = interface_args.InstantiateFrom(
            type_arguments, Object::null_type_arguments(), kNoneFree, space);
      }
      interface_args = interface_class.GetInstanceTypeArguments(
          thread, interface_args, /*canonicalize=*/false);
      // In Dart 2, implementing Function has no meaning.
      // TODO(regis): Can we encounter and skip Object as well?
      if (interface_class.IsDartFunctionClass()) {
        continue;
      }
      if (Class::IsSubtypeOf(interface_class, interface_args,
                             Nullability::kNonNullable, other, space,
                             function_type_equivalence)) {
        TRACE_TYPE_CHECKS_VERBOSE("   - result: true (interface found)\n");
        return true;
      }
    }
    // "Recurse" up the class hierarchy until we have reached the top.
    this_class = this_class.SuperClass();
    if (this_class.IsNull()) {
      TRACE_TYPE_CHECKS_VERBOSE("   - result: false (supertype not found)\n");
      return false;
    }
    this_cid = this_class.id();
  }
  UNREACHABLE();
  return false;
}

◆ IsTopLevel()

bool dart::Class::IsTopLevel ( ) const

Definition at line 6176 of file object.cc.

                             {
  return Name() == Symbols::TopLevel().ptr();
}

◆ IsVoidClass()

bool dart::Class::IsVoidClass ( ) const

inline

Definition at line 1561 of file object.h.

1561{ return id() == kVoidCid; }

◆ kernel_offset()

intptr_t dart::Class::kernel_offset ( ) const

inline

Definition at line 1806 of file object.h.

                                 {
#if defined(DART_PRECOMPILED_RUNTIME)
    return 0;
#else
    return untag()->kernel_offset_;
#endif
  }

◆ KernelProgramInfo()

KernelProgramInfoPtr dart::Class::KernelProgramInfo ( ) const

Definition at line 5615 of file object.cc.

                                                    {
  const auto& lib = Library::Handle(library());
  return lib.kernel_program_info();
}

◆ library()

LibraryPtr dart::Class::library ( ) const

inline

Definition at line 1335 of file object.h.

1335{ return untag()->library(); }

◆ LookupCanonicalInstance()

InstancePtr dart::Class::LookupCanonicalInstance	(	Zone *	zone,
		const Instance &	value
	)		const

Definition at line 6527 of file object.cc.

                                                                        {
  ASSERT(this->ptr() == value.clazz());
  ASSERT(is_finalized() || is_prefinalized());
  Instance& canonical_value = Instance::Handle(zone);
  if (this->constants() != Array::null()) {
    CanonicalInstancesSet constants(zone, this->constants());
    canonical_value ^= constants.GetOrNull(CanonicalInstanceKey(value));
    this->set_constants(constants.Release());
  }
  return canonical_value.ptr();
}

◆ LookupConstructor()

FunctionPtr dart::Class::LookupConstructor ( const String & name ) const

Definition at line 6202 of file object.cc.

                                                             {
  Thread* thread = Thread::Current();
  SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
  return LookupFunctionReadLocked(name, kConstructor);
}

◆ LookupConstructorAllowPrivate()

FunctionPtr dart::Class::LookupConstructorAllowPrivate ( const String & name ) const

Definition at line 6208 of file object.cc.

                                                                         {
  return LookupFunctionAllowPrivate(name, kConstructor);
}

◆ LookupDynamicFunctionAllowPrivate()

FunctionPtr dart::Class::LookupDynamicFunctionAllowPrivate ( const String & name ) const

Definition at line 6188 of file object.cc.

                                                                             {
  return LookupFunctionAllowPrivate(name, kInstance);
}

◆ LookupDynamicFunctionUnsafe()

FunctionPtr dart::Class::LookupDynamicFunctionUnsafe ( const String & name ) const

Definition at line 6184 of file object.cc.

                                                                       {
  return LookupFunctionReadLocked(name, kInstance);
}

◆ LookupFactory()

FunctionPtr dart::Class::LookupFactory ( const String & name ) const

Definition at line 6212 of file object.cc.

                                                         {
  Thread* thread = Thread::Current();
  SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
  return LookupFunctionReadLocked(name, kFactory);
}

◆ LookupFactoryAllowPrivate()

FunctionPtr dart::Class::LookupFactoryAllowPrivate ( const String & name ) const

Definition at line 6218 of file object.cc.

                                                                     {
  return LookupFunctionAllowPrivate(name, kFactory);
}

◆ LookupField()

FieldPtr dart::Class::LookupField ( const String & name ) const

Definition at line 6407 of file object.cc.

                                                    {
  return LookupField(name, kAny);
}

◆ LookupFieldAllowPrivate()

FieldPtr dart::Class::LookupFieldAllowPrivate	(	const String &	name,
		bool	instance_only = `false`
	)		const

Definition at line 6458 of file object.cc.

                                                                  {
  ASSERT(!IsNull());
  // Use slow string compare, ignoring privacy name mangling.
  Thread* thread = Thread::Current();
  if (EnsureIsFinalized(thread) != Error::null()) {
    return Field::null();
  }
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  REUSABLE_FIELD_HANDLESCOPE(thread);
  REUSABLE_STRING_HANDLESCOPE(thread);
  Array& flds = thread->ArrayHandle();
  flds = fields();
  ASSERT(!flds.IsNull());
  intptr_t len = flds.Length();
  Field& field = thread->FieldHandle();
  String& field_name = thread->StringHandle();
  for (intptr_t i = 0; i < len; i++) {
    field ^= flds.At(i);
    field_name = field.name();
    if (field.is_static() && instance_only) {
      // If we only care about instance fields, skip statics.
      continue;
    }
    if (String::EqualsIgnoringPrivateKey(field_name, name)) {
      return field.ptr();
    }
  }
  return Field::null();
}

◆ LookupFunctionAllowPrivate()

FunctionPtr dart::Class::LookupFunctionAllowPrivate ( const String & name ) const

Definition at line 6222 of file object.cc.

                                                                      {
  return LookupFunctionAllowPrivate(name, kAny);
}

◆ LookupFunctionReadLocked()

FunctionPtr dart::Class::LookupFunctionReadLocked ( const String & name ) const

Definition at line 6226 of file object.cc.

                                                                    {
  return LookupFunctionReadLocked(name, kAny);
}

◆ LookupGetterFunction()

FunctionPtr dart::Class::LookupGetterFunction ( const String & name ) const

Definition at line 6363 of file object.cc.

                                                                {
  return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
}

◆ LookupInstanceField()

FieldPtr dart::Class::LookupInstanceField ( const String & name ) const

Definition at line 6399 of file object.cc.

                                                            {
  return LookupField(name, kInstance);
}

◆ LookupInstanceFieldAllowPrivate()

FieldPtr dart::Class::LookupInstanceFieldAllowPrivate ( const String & name ) const

Definition at line 6489 of file object.cc.

                                                                        {
  Field& field = Field::Handle(LookupFieldAllowPrivate(name, true));
  if (!field.IsNull() && !field.is_static()) {
    return field.ptr();
  }
  return Field::null();
}

◆ LookupSetterFunction()

FunctionPtr dart::Class::LookupSetterFunction ( const String & name ) const

Definition at line 6367 of file object.cc.

                                                                {
  return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
}

◆ LookupStaticField()

FieldPtr dart::Class::LookupStaticField ( const String & name ) const

Definition at line 6403 of file object.cc.

                                                          {
  return LookupField(name, kStatic);
}

◆ LookupStaticFieldAllowPrivate()

FieldPtr dart::Class::LookupStaticFieldAllowPrivate ( const String & name ) const

Definition at line 6497 of file object.cc.

                                                                      {
  Field& field = Field::Handle(LookupFieldAllowPrivate(name));
  if (!field.IsNull() && field.is_static()) {
    return field.ptr();
  }
  return Field::null();
}

◆ LookupStaticFunction()

FunctionPtr dart::Class::LookupStaticFunction ( const String & name ) const

Definition at line 6192 of file object.cc.

                                                                {
  Thread* thread = Thread::Current();
  SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
  return LookupFunctionReadLocked(name, kStatic);
}

◆ LookupStaticFunctionAllowPrivate()

FunctionPtr dart::Class::LookupStaticFunctionAllowPrivate ( const String & name ) const

Definition at line 6198 of file object.cc.

                                                                            {
  return LookupFunctionAllowPrivate(name, kStatic);
}

◆ MarkFieldBoxedDuringReload()

void dart::Class::MarkFieldBoxedDuringReload	(	ClassTable *	class_table,
		const Field &	field
	)		const

Definition at line 605 of file object_reload.cc.

                                                                 {
  if (!field.is_unboxed()) {
    return;
  }
 
  field.set_is_unboxed_unsafe(false);
 
  // Make sure to update the bitmap used for scanning.
  auto unboxed_fields_map = class_table->GetUnboxedFieldsMapAt(id());
  const auto start_index = field.HostOffset() >> kCompressedWordSizeLog2;
  const auto end_index =
      start_index + (Class::UnboxedFieldSizeInBytesByCid(field.guarded_cid()) >>
                     kCompressedWordSizeLog2);
  ASSERT(unboxed_fields_map.Get(start_index));
  for (intptr_t i = start_index; i < end_index; i++) {
    unboxed_fields_map.Clear(i);
  }
  class_table->SetUnboxedFieldsMapAt(id(), unboxed_fields_map);
}

◆ MigrateImplicitStaticClosures()

void dart::Class::MigrateImplicitStaticClosures	(	ProgramReloadContext *	context,
		const Class &	new_cls
	)		const

Definition at line 319 of file object_reload.cc.

                                                                      {
  const Array& funcs = Array::Handle(current_functions());
  Thread* thread = Thread::Current();
  Function& old_func = Function::Handle();
  String& selector = String::Handle();
  Function& new_func = Function::Handle();
  Closure& old_closure = Closure::Handle();
  Closure& new_closure = Closure::Handle();
  for (intptr_t i = 0; i < funcs.Length(); i++) {
    old_func ^= funcs.At(i);
    if (old_func.is_static() && old_func.HasImplicitClosureFunction()) {
      selector = old_func.name();
      new_func = Resolver::ResolveFunction(thread->zone(), new_cls, selector);
      if (!new_func.IsNull() && new_func.is_static()) {
        old_func = old_func.ImplicitClosureFunction();
        old_closure = old_func.ImplicitStaticClosure();
        new_func = new_func.ImplicitClosureFunction();
        new_closure = new_func.ImplicitStaticClosure();
        if (old_closure.IsCanonical()) {
          new_closure.SetCanonical();
        }
        irc->AddBecomeMapping(old_closure, new_closure);
      }
    }
  }
}

◆ Mixin()

ClassPtr dart::Class::Mixin ( ) const

Definition at line 3081 of file object.cc.

                            {
  if (is_transformed_mixin_application()) {
    const Array& interfaces = Array::Handle(this->interfaces());
    const Type& mixin_type =
        Type::Handle(Type::RawCast(interfaces.At(interfaces.Length() - 1)));
    return mixin_type.type_class();
  }
  return ptr();
}

◆ Name()

StringPtr dart::Class::Name ( ) const

Definition at line 3038 of file object.cc.

                            {
  return untag()->name();
}

◆ NameCString()

const char * dart::Class::NameCString ( NameVisibility name_visibility ) const

Definition at line 3067 of file object.cc.

                                                                   {
  switch (name_visibility) {
    case Object::kInternalName:
      return String::Handle(Name()).ToCString();
    case Object::kScrubbedName:
      return ScrubbedNameCString();
    case Object::kUserVisibleName:
      return UserVisibleNameCString();
    default:
      UNREACHABLE();
      return nullptr;
  }
}

◆ New() [1/2]

ClassPtr dart::Class::New	(	const Library &	lib,
		const String &	name,
		const Script &	script,
		TokenPosition	token_pos,
		bool	register_class = `true`
	)

static

Definition at line 5216 of file object.cc.

                                         {
  Class& result =
      Class::Handle(NewCommon<Instance, RTN::Instance>(kIllegalCid));
  result.set_library(lib);
  result.set_name(name);
  result.set_script(script);
  NOT_IN_PRECOMPILED(result.set_token_pos(token_pos));
 
  // The size gets initialized to 0. Once the class gets finalized the class
  // finalizer will set the correct size.
  ASSERT(!result.is_finalized() && !result.is_prefinalized());
  result.set_instance_size_in_words(0, 0);
 
  if (register_class) {
    IsolateGroup::Current()->RegisterClass(result);
  }
  return result.ptr();
}

◆ New() [2/2]

template<class FakeObject , class TargetFakeObject >

ClassPtr dart::Class::New	(	IsolateGroup *	isolate_group,
		bool	register_class = `true`
	)

static

Definition at line 3114 of file object.cc.

                                                                    {
  ASSERT(Object::class_class() != Class::null());
  const auto& result = Class::Handle(Object::Allocate<Class>(Heap::kOld));
  Object::VerifyBuiltinVtable<FakeObject>(FakeObject::kClassId);
  NOT_IN_PRECOMPILED(result.set_token_pos(TokenPosition::kNoSource));
  NOT_IN_PRECOMPILED(result.set_end_token_pos(TokenPosition::kNoSource));
  result.set_instance_size(FakeObject::InstanceSize(),
                           compiler::target::RoundedAllocationSize(
                               TargetFakeObject::InstanceSize()));
  result.set_type_arguments_field_offset_in_words(kNoTypeArguments,
                                                  RTN::Class::kNoTypeArguments);
  const intptr_t host_next_field_offset = FakeObject::NextFieldOffset();
  const intptr_t target_next_field_offset = TargetFakeObject::NextFieldOffset();
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  COMPILE_ASSERT((FakeObject::kClassId != kInstanceCid));
  result.set_id(FakeObject::kClassId);
  NOT_IN_PRECOMPILED(result.set_implementor_cid(kIllegalCid));
  result.set_num_type_arguments_unsafe(0);
  result.set_num_native_fields(0);
  result.set_state_bits(0);
  if (IsInternalOnlyClassId(FakeObject::kClassId) ||
      (FakeObject::kClassId == kTypeArgumentsCid)) {
    // VM internal classes are done. There is no finalization needed or
    // possible in this case.
    result.set_is_declaration_loaded();
    result.set_is_type_finalized();
    result.set_is_allocate_finalized();
  } else if (FakeObject::kClassId != kClosureCid) {
    // VM backed classes are almost ready: run checks and resolve class
    // references, but do not recompute size.
    result.set_is_prefinalized();
  }
  if (FakeObject::kClassId < kNumPredefinedCids &&
      IsDeeplyImmutableCid(FakeObject::kClassId)) {
    result.set_is_deeply_immutable(true);
  }
  NOT_IN_PRECOMPILED(result.set_kernel_offset(0));
  result.InitEmptyFields();
  if (register_class) {
    isolate_group->class_table()->Register(result);
  }
  return result.ptr();
}

◆ NewExternalTypedDataClass()

ClassPtr dart::Class::NewExternalTypedDataClass	(	intptr_t	class_id,
		IsolateGroup *	isolate
	)

static

Definition at line 5373 of file object.cc.

                                                                       {
  ASSERT(IsExternalTypedDataClassId(class_id));
  const intptr_t host_instance_size = ExternalTypedData::InstanceSize();
  const intptr_t target_instance_size = compiler::target::RoundedAllocationSize(
      RTN::ExternalTypedData::InstanceSize());
  Class& result = Class::Handle(New<ExternalTypedData, RTN::ExternalTypedData>(
      class_id, isolate_group, /*register_class=*/false));
 
  const intptr_t host_next_field_offset = ExternalTypedData::NextFieldOffset();
  const intptr_t target_next_field_offset =
      RTN::ExternalTypedData::NextFieldOffset();
  result.set_instance_size(host_instance_size, target_instance_size);
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NewNativeWrapper()

ClassPtr dart::Class::NewNativeWrapper	(	const Library &	library,
		const String &	name,
		int	num_fields
	)

static

Definition at line 5244 of file object.cc.

                                                  {
  Class& cls = Class::Handle(library.LookupClass(name));
  if (cls.IsNull()) {
    cls = New(library, name, Script::Handle(), TokenPosition::kNoSource);
    cls.SetFields(Object::empty_array());
    cls.SetFunctions(Object::empty_array());
    // Set super class to Object.
    cls.set_super_type(Type::Handle(Type::ObjectType()));
    // Compute instance size. First word contains a pointer to a properly
    // sized typed array once the first native field has been set.
    const intptr_t host_instance_size =
        sizeof(UntaggedInstance) + kCompressedWordSize;
#if defined(DART_PRECOMPILER)
    const intptr_t target_instance_size =
        compiler::target::Instance::InstanceSize() +
        compiler::target::kCompressedWordSize;
#else
    const intptr_t target_instance_size =
        sizeof(UntaggedInstance) + compiler::target::kCompressedWordSize;
#endif
    cls.set_instance_size(
        RoundedAllocationSize(host_instance_size),
        compiler::target::RoundedAllocationSize(target_instance_size));
    cls.set_next_field_offset(host_instance_size, target_instance_size);
    cls.set_num_native_fields(field_count);
    cls.set_is_allocate_finalized();
    // The signature of the constructor yet to be added to this class will have
    // to be finalized explicitly, since the class is prematurely marked as
    // 'is_allocate_finalized' and finalization of member types will not occur.
    cls.set_is_declaration_loaded();
    cls.set_is_type_finalized();
    cls.set_is_synthesized_class();
    cls.set_is_isolate_unsendable(true);
    NOT_IN_PRECOMPILED(cls.set_implementor_cid(kDynamicCid));
    library.AddClass(cls);
    return cls.ptr();
  } else {
    return Class::null();
  }
}

◆ NewPointerClass()

ClassPtr dart::Class::NewPointerClass	(	intptr_t	class_id,
		IsolateGroup *	isolate_group
	)

static

Definition at line 5393 of file object.cc.

                                                             {
  ASSERT(IsFfiPointerClassId(class_id));
  intptr_t host_instance_size = Pointer::InstanceSize();
  intptr_t target_instance_size =
      compiler::target::RoundedAllocationSize(RTN::Pointer::InstanceSize());
  Class& result = Class::Handle(New<Pointer, RTN::Pointer>(
      class_id, isolate_group, /*register_class=*/false));
  result.set_instance_size(host_instance_size, target_instance_size);
  result.set_type_arguments_field_offset(Pointer::type_arguments_offset(),
                                         RTN::Pointer::type_arguments_offset());
 
  const intptr_t host_next_field_offset = Pointer::NextFieldOffset();
  const intptr_t target_next_field_offset = RTN::Pointer::NextFieldOffset();
 
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NewStringClass()

ClassPtr dart::Class::NewStringClass	(	intptr_t	class_id,
		IsolateGroup *	isolate_group
	)

static

Definition at line 5287 of file object.cc.

                                                                             {
  intptr_t host_instance_size, target_instance_size;
  if (class_id == kOneByteStringCid) {
    host_instance_size = OneByteString::InstanceSize();
    target_instance_size = compiler::target::RoundedAllocationSize(
        RTN::OneByteString::InstanceSize());
  } else {
    ASSERT(class_id == kTwoByteStringCid);
    host_instance_size = TwoByteString::InstanceSize();
    target_instance_size = compiler::target::RoundedAllocationSize(
        RTN::TwoByteString::InstanceSize());
  }
  Class& result = Class::Handle(New<String, RTN::String>(
      class_id, isolate_group, /*register_class=*/false));
  result.set_instance_size(host_instance_size, target_instance_size);
 
  const intptr_t host_next_field_offset = String::NextFieldOffset();
  const intptr_t target_next_field_offset = RTN::String::NextFieldOffset();
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  ASSERT(IsDeeplyImmutableCid(class_id));
  result.set_is_deeply_immutable(true);
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NewTypedDataClass()

ClassPtr dart::Class::NewTypedDataClass	(	intptr_t	class_id,
		IsolateGroup *	isolate_group
	)

static

Definition at line 5314 of file object.cc.

                                                               {
  ASSERT(IsTypedDataClassId(class_id));
  const intptr_t host_instance_size = TypedData::InstanceSize();
  const intptr_t target_instance_size =
      compiler::target::RoundedAllocationSize(RTN::TypedData::InstanceSize());
  Class& result = Class::Handle(New<TypedData, RTN::TypedData>(
      class_id, isolate_group, /*register_class=*/false));
  result.set_instance_size(host_instance_size, target_instance_size);
 
  const intptr_t host_next_field_offset = TypedData::NextFieldOffset();
  const intptr_t target_next_field_offset = RTN::TypedData::NextFieldOffset();
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NewTypedDataViewClass()

ClassPtr dart::Class::NewTypedDataViewClass	(	intptr_t	class_id,
		IsolateGroup *	isolate_group
	)

static

Definition at line 5333 of file object.cc.

                                                                   {
  ASSERT(IsTypedDataViewClassId(class_id));
  const intptr_t host_instance_size = TypedDataView::InstanceSize();
  const intptr_t target_instance_size = compiler::target::RoundedAllocationSize(
      RTN::TypedDataView::InstanceSize());
  Class& result = Class::Handle(New<TypedDataView, RTN::TypedDataView>(
      class_id, isolate_group, /*register_class=*/false));
  result.set_instance_size(host_instance_size, target_instance_size);
 
  const intptr_t host_next_field_offset = TypedDataView::NextFieldOffset();
  const intptr_t target_next_field_offset =
      RTN::TypedDataView::NextFieldOffset();
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NewUnmodifiableTypedDataViewClass()

ClassPtr dart::Class::NewUnmodifiableTypedDataViewClass	(	intptr_t	class_id,
		IsolateGroup *	isolate_group
	)

static

Definition at line 5353 of file object.cc.

                                                                               {
  ASSERT(IsUnmodifiableTypedDataViewClassId(class_id));
  const intptr_t host_instance_size = TypedDataView::InstanceSize();
  const intptr_t target_instance_size = compiler::target::RoundedAllocationSize(
      RTN::TypedDataView::InstanceSize());
  Class& result = Class::Handle(New<TypedDataView, RTN::TypedDataView>(
      class_id, isolate_group, /*register_class=*/false));
  result.set_instance_size(host_instance_size, target_instance_size);
 
  const intptr_t host_next_field_offset = TypedDataView::NextFieldOffset();
  const intptr_t target_next_field_offset =
      RTN::TypedDataView::NextFieldOffset();
  result.set_next_field_offset(host_next_field_offset,
                               target_next_field_offset);
  result.set_is_prefinalized();
  isolate_group->class_table()->Register(result);
  return result.ptr();
}

◆ NoteImplementor()

bool dart::Class::NoteImplementor ( const Class & implementor ) const

Definition at line 5635 of file object.cc.

                                                          {
  ASSERT(!implementor.is_abstract());
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  if (implementor_cid() == kDynamicCid) {
    return false;
  } else if (implementor_cid() == implementor.id()) {
    return false;
  } else if (implementor_cid() == kIllegalCid) {
    set_implementor_cid(implementor.id());
    return true;  // None -> One
  } else {
    set_implementor_cid(kDynamicCid);
    return true;  // One -> Many
  }
}

◆ num_native_fields()

uint16_t dart::Class::num_native_fields ( ) const

inline

Definition at line 1790 of file object.h.

1790{ return untag()->num_native_fields_; }

◆ num_type_arguments_offset()

static intptr_t dart::Class::num_type_arguments_offset ( )

inlinestatic

Definition at line 1254 of file object.h.

                                              {
    return OFFSET_OF(UntaggedClass, num_type_arguments_);
  }

◆ NumNativeFieldsOf()

static uint16_t dart::Class::NumNativeFieldsOf ( ClassPtr clazz )

inlinestatic

Definition at line 1794 of file object.h.

                                                    {
    return clazz->untag()->num_native_fields_;
  }

◆ NumTypeArguments()

intptr_t dart::Class::NumTypeArguments ( ) const

Definition at line 3690 of file object.cc.

                                       {
  // Return cached value if already calculated.
  intptr_t num_type_args = num_type_arguments();
  if (num_type_args != kUnknownNumTypeArguments) {
    return num_type_args;
  }
 
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
  return 0;
#else
  num_type_args = ComputeNumTypeArguments();
  ASSERT(num_type_args != kUnknownNumTypeArguments);
  set_num_type_arguments(num_type_args);
  return num_type_args;
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ NumTypeParameters() [1/2]

intptr_t dart::Class::NumTypeParameters ( ) const

inline

Definition at line 1346 of file object.h.

                                     {
    return NumTypeParameters(Thread::Current());
  }

◆ NumTypeParameters() [2/2]

intptr_t dart::Class::NumTypeParameters ( Thread * thread ) const

Definition at line 3605 of file object.cc.

                                                      {
  if (!is_declaration_loaded()) {
    ASSERT(is_prefinalized());
    const intptr_t cid = id();
    if ((cid == kArrayCid) || (cid == kImmutableArrayCid) ||
        (cid == kGrowableObjectArrayCid)) {
      return 1;  // List's type parameter may not have been parsed yet.
    }
    return 0;
  }
  if (type_parameters() == TypeParameters::null()) {
    return 0;
  }
  REUSABLE_TYPE_PARAMETERS_HANDLESCOPE(thread);
  TypeParameters& type_params = thread->TypeParametersHandle();
  type_params = type_parameters();
  return type_params.Length();
}

◆ OffsetToFieldMap()

ArrayPtr dart::Class::OffsetToFieldMap ( ClassTable * class_table = nullptr ) const

Definition at line 3233 of file object.cc.

                                     {
  ASSERT(is_finalized());
  if (untag()->offset_in_words_to_field<std::memory_order_acquire>() ==
      Array::null()) {
    // Even if multiple threads are calling this concurrently, all of them would
    // compute the same array, so we intentionally don't acquire any locks here.
    const intptr_t length = untag()->host_instance_size_in_words_;
    const Array& array = Array::Handle(Array::New(length, Heap::kOld));
    Class& cls = Class::Handle(this->ptr());
    Array& fields = Array::Handle();
    Field& f = Field::Handle();
    while (!cls.IsNull()) {
      fields = cls.fields();
      for (intptr_t i = 0; i < fields.Length(); ++i) {
        f ^= fields.At(i);
        if (f.is_instance()) {
          array.SetAt(f.HostOffset() >> kCompressedWordSizeLog2, f);
        }
      }
      cls = cls.SuperClass(class_table);
    }
    untag()->set_offset_in_words_to_field<std::memory_order_release>(
        array.ptr());
  }
  return untag()->offset_in_words_to_field<std::memory_order_acquire>();
}

◆ PatchFieldsAndFunctions()

void dart::Class::PatchFieldsAndFunctions ( ) const

Definition at line 270 of file object_reload.cc.

                                          {
  // Move all old functions and fields to a patch class so that they
  // still refer to their original script.
  const auto& kernel_info = KernelProgramInfo::Handle(KernelProgramInfo());
  const PatchClass& patch = PatchClass::Handle(
      PatchClass::New(*this, kernel_info, Script::Handle(script())));
  ASSERT(!patch.IsNull());
  const Library& lib = Library::Handle(library());
  patch.set_kernel_library_index(lib.kernel_library_index());
 
  const Array& funcs = Array::Handle(current_functions());
  Function& func = Function::Handle();
  Object& owner = Object::Handle();
  for (intptr_t i = 0; i < funcs.Length(); i++) {
    func = Function::RawCast(funcs.At(i));
    if ((func.token_pos() == TokenPosition::kMinSource) ||
        func.IsClosureFunction()) {
      // Eval functions do not need to have their script updated.
      //
      // Closure functions refer to the parent's script which we can
      // rely on being updated for us, if necessary.
      continue;
    }
 
    // If the source for this function is already patched, leave it alone.
    owner = func.RawOwner();
    ASSERT(!owner.IsNull());
    if (!owner.IsPatchClass()) {
      ASSERT(owner.ptr() == this->ptr());
      func.set_owner(patch);
    }
  }
 
  Thread* thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  const Array& field_list = Array::Handle(fields());
  Field& field = Field::Handle();
  for (intptr_t i = 0; i < field_list.Length(); i++) {
    field = Field::RawCast(field_list.At(i));
    owner = field.RawOwner();
    ASSERT(!owner.IsNull());
    if (!owner.IsPatchClass()) {
      ASSERT(owner.ptr() == this->ptr());
      field.set_owner(patch);
    }
    field.ForceDynamicGuardedCidAndLength();
  }
}

◆ RareType()

TypePtr dart::Class::RareType ( ) const

Definition at line 3097 of file object.cc.

                              {
  if (!IsGeneric()) {
    return DeclarationType();
  }
  ASSERT(is_declaration_loaded());
  Thread* const thread = Thread::Current();
  Zone* const zone = thread->zone();
  const auto& inst_to_bounds =
      TypeArguments::Handle(zone, DefaultTypeArguments(zone));
  ASSERT(inst_to_bounds.ptr() != Object::empty_type_arguments().ptr());
  auto& type = Type::Handle(
      zone, Type::New(*this, inst_to_bounds, Nullability::kNonNullable));
  type ^= ClassFinalizer::FinalizeType(type);
  return type.ptr();
}

◆ RegisterCHACode()

void dart::Class::RegisterCHACode ( const Code & code )

Definition at line 4445 of file object.cc.

                                            {
  if (FLAG_trace_cha) {
    THR_Print("RegisterCHACode '%s' depends on class '%s'\n",
              Function::Handle(code.function()).ToQualifiedCString(),
              ToCString());
  }
  DEBUG_ASSERT(IsMutatorOrAtDeoptSafepoint());
  ASSERT(code.is_optimized());
  CHACodeArray a(*this);
  a.Register(code);
}

◆ script()

ScriptPtr dart::Class::script ( ) const

inline

Definition at line 1274 of file object.h.

1274{ return untag()->script(); }

◆ ScrubbedName()

StringPtr dart::Class::ScrubbedName ( ) const

Definition at line 3042 of file object.cc.

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

◆ ScrubbedNameCString()

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

Definition at line 3046 of file object.cc.

                                             {
  return String::ScrubName(String::Handle(Name()));
}

◆ set_allocation_stub()

void dart::Class::set_allocation_stub ( const Code & value ) const

Definition at line 5925 of file object.cc.

                                                       {
  // Never clear the stub as it may still be a target, but will be GC-d if
  // not referenced.
  ASSERT(!value.IsNull());
  ASSERT(untag()->allocation_stub() == Code::null());
  untag()->set_allocation_stub(value.ptr());
}

◆ set_can_be_future()

void dart::Class::set_can_be_future ( bool value ) const

Definition at line 3215 of file object.cc.

                                              {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(CanBeFutureBit::update(value, state_bits()));
}

◆ set_constants()

void dart::Class::set_constants ( const Array & value ) const

Definition at line 5865 of file object.cc.

                                                  {
  untag()->set_constants(value.ptr());
}

◆ set_dependent_code()

void dart::Class::set_dependent_code ( const WeakArray & array ) const

Definition at line 4481 of file object.cc.

                                                           {
  DEBUG_ASSERT(
      IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  untag()->set_dependent_code(array.ptr());
}

◆ set_direct_implementors()

void dart::Class::set_direct_implementors ( const GrowableObjectArray & implementors ) const

Definition at line 5827 of file object.cc.

                                                   {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  untag()->set_direct_implementors(implementors.ptr());
}

◆ set_direct_subclasses()

void dart::Class::set_direct_subclasses ( const GrowableObjectArray & subclasses ) const

Definition at line 5854 of file object.cc.

                                                                             {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  untag()->set_direct_subclasses(subclasses.ptr());
}

◆ set_end_token_pos()

void dart::Class::set_end_token_pos ( TokenPosition value ) const

Definition at line 5625 of file object.cc.

                                                           {
  ASSERT(!token_pos.IsClassifying());
  StoreNonPointer(&untag()->end_token_pos_, token_pos);
}

◆ set_has_pragma()

void dart::Class::set_has_pragma ( bool value ) const

Definition at line 3190 of file object.cc.

                                           {
  set_state_bits(HasPragmaBit::update(value, state_bits()));
}

◆ set_id()

void dart::Class::set_id ( intptr_t value ) const

inline

Definition at line 1236 of file object.h.

                                    {
    ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());
    StoreNonPointer(&untag()->id_, value);
  }

◆ set_instance_size()

void dart::Class::set_instance_size	(	intptr_t	host_value_in_bytes,
		intptr_t	target_value_in_bytes
	)		const

inline

Definition at line 1169 of file object.h.

                                                               {
    ASSERT(kCompressedWordSize != 0);
    set_instance_size_in_words(
        host_value_in_bytes / kCompressedWordSize,
        target_value_in_bytes / compiler::target::kCompressedWordSize);
  }

◆ set_instance_size_in_words()

void dart::Class::set_instance_size_in_words	(	intptr_t	host_value,
		intptr_t	target_value
	)		const

inline

Definition at line 1176 of file object.h.

                                                               {
    ASSERT(
        Utils::IsAligned((host_value * kCompressedWordSize), kObjectAlignment));
    StoreNonPointer(&untag()->host_instance_size_in_words_, host_value);
#if defined(DART_PRECOMPILER)
    ASSERT(
        Utils::IsAligned((target_value * compiler::target::kCompressedWordSize),
                         compiler::target::kObjectAlignment));
    StoreNonPointer(&untag()->target_instance_size_in_words_, target_value);
#else
    // Could be different only during cross-compilation.
    ASSERT_EQUAL(host_value, target_value);
#endif  // defined(DART_PRECOMPILER)
  }

◆ set_interfaces()

void dart::Class::set_interfaces ( const Array & value ) const

Definition at line 5794 of file object.cc.

                                                   {
  ASSERT(!value.IsNull());
  untag()->set_interfaces(value.ptr());
}

◆ set_is_abstract()

void dart::Class::set_is_abstract ( ) const

Definition at line 5677 of file object.cc.

                                  {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(AbstractBit::update(true, state_bits()));
}

◆ set_is_allocate_finalized()

void dart::Class::set_is_allocate_finalized ( ) const

Definition at line 5780 of file object.cc.

                                            {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!is_allocate_finalized());
  set_state_bits(ClassFinalizedBits::update(UntaggedClass::kAllocateFinalized,
                                            state_bits()));
}

◆ set_is_allocated()

void dart::Class::set_is_allocated ( bool value ) const

Definition at line 5755 of file object.cc.

                                             {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_is_allocated_unsafe(value);
}

◆ set_is_allocated_unsafe()

void dart::Class::set_is_allocated_unsafe ( bool value ) const

Definition at line 5760 of file object.cc.

                                                    {
  set_state_bits(IsAllocatedBit::update(value, state_bits()));
}

◆ set_is_base_class()

void dart::Class::set_is_base_class ( ) const

Definition at line 5735 of file object.cc.

                                    {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(BaseClassBit::update(true, state_bits()));
}

◆ set_is_const()

void dart::Class::set_is_const ( ) const

Definition at line 5715 of file object.cc.

                               {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(ConstBit::update(true, state_bits()));
}

◆ set_is_declaration_loaded()

void dart::Class::set_is_declaration_loaded ( ) const

Definition at line 5682 of file object.cc.

                                            {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_is_declaration_loaded_unsafe();
}

◆ set_is_declaration_loaded_unsafe()

void dart::Class::set_is_declaration_loaded_unsafe ( ) const

Definition at line 5687 of file object.cc.

                                                   {
  ASSERT(!is_declaration_loaded());
  set_state_bits(ClassLoadingBits::update(UntaggedClass::kDeclarationLoaded,
                                          state_bits()));
}

◆ set_is_deeply_immutable()

void dart::Class::set_is_deeply_immutable ( bool value ) const

Definition at line 3205 of file object.cc.

                                                    {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(IsDeeplyImmutableBit::update(value, state_bits()));
}

◆ set_is_enum_class()

void dart::Class::set_is_enum_class ( ) const

Definition at line 5710 of file object.cc.

                                    {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(EnumBit::update(true, state_bits()));
}

◆ set_is_fields_marked_nullable()

void dart::Class::set_is_fields_marked_nullable ( ) const

Definition at line 5750 of file object.cc.

                                                {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(FieldsMarkedNullableBit::update(true, state_bits()));
}

◆ set_is_final()

void dart::Class::set_is_final ( ) const

Definition at line 5745 of file object.cc.

                               {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(FinalBit::update(true, state_bits()));
}

◆ set_is_finalized()

void dart::Class::set_is_finalized ( ) const

Definition at line 5769 of file object.cc.

                                   {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!is_finalized());
  set_is_finalized_unsafe();
}

◆ set_is_finalized_unsafe()

void dart::Class::set_is_finalized_unsafe ( ) const

Definition at line 5775 of file object.cc.

                                          {
  set_state_bits(
      ClassFinalizedBits::update(UntaggedClass::kFinalized, state_bits()));
}

◆ set_is_future_subtype()

void dart::Class::set_is_future_subtype ( bool value ) const

Definition at line 3210 of file object.cc.

                                                  {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(IsFutureSubtypeBit::update(value, state_bits()));
}

◆ set_is_implemented()

void dart::Class::set_is_implemented ( ) const

Definition at line 5668 of file object.cc.

                                     {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_is_implemented_unsafe();
}

◆ set_is_implemented_unsafe()

void dart::Class::set_is_implemented_unsafe ( ) const

Definition at line 5673 of file object.cc.

                                            {
  set_state_bits(ImplementedBit::update(true, state_bits()));
}

◆ set_is_interface_class()

void dart::Class::set_is_interface_class ( ) const

Definition at line 5740 of file object.cc.

                                         {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(InterfaceClassBit::update(true, state_bits()));
}

◆ set_is_isolate_unsendable()

void dart::Class::set_is_isolate_unsendable ( bool value ) const

Definition at line 3194 of file object.cc.

                                                      {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(IsIsolateUnsendableBit::update(value, state_bits()));
}

◆ set_is_isolate_unsendable_due_to_pragma()

void dart::Class::set_is_isolate_unsendable_due_to_pragma ( bool value ) const

Definition at line 3199 of file object.cc.

                                                                    {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(
      IsIsolateUnsendableDueToPragmaBit::update(value, state_bits()));
}

◆ set_is_loaded()

void dart::Class::set_is_loaded ( bool value ) const

Definition at line 5764 of file object.cc.

                                          {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(IsLoadedBit::update(value, state_bits()));
}

◆ set_is_mixin_class()

void dart::Class::set_is_mixin_class ( ) const

Definition at line 5730 of file object.cc.

                                     {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(MixinClassBit::update(true, state_bits()));
}

◆ set_is_prefinalized()

void dart::Class::set_is_prefinalized ( ) const

Definition at line 5787 of file object.cc.

                                      {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(!is_finalized());
  set_state_bits(
      ClassFinalizedBits::update(UntaggedClass::kPreFinalized, state_bits()));
}

◆ set_is_sealed()

void dart::Class::set_is_sealed ( ) const

Definition at line 5725 of file object.cc.

                                {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(SealedBit::update(true, state_bits()));
}

◆ set_is_synthesized_class()

void dart::Class::set_is_synthesized_class ( ) const

Definition at line 5701 of file object.cc.

                                           {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_is_synthesized_class_unsafe();
}

◆ set_is_synthesized_class_unsafe()

void dart::Class::set_is_synthesized_class_unsafe ( ) const

Definition at line 5706 of file object.cc.

                                                  {
  set_state_bits(SynthesizedClassBit::update(true, state_bits()));
}

◆ set_is_transformed_mixin_application()

void dart::Class::set_is_transformed_mixin_application ( ) const

Definition at line 5720 of file object.cc.

                                                       {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  set_state_bits(TransformedMixinApplicationBit::update(true, state_bits()));
}

◆ set_is_type_finalized()

void dart::Class::set_is_type_finalized ( ) const

Definition at line 5693 of file object.cc.

                                        {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  ASSERT(is_declaration_loaded());
  ASSERT(!is_type_finalized());
  set_state_bits(
      ClassLoadingBits::update(UntaggedClass::kTypeFinalized, state_bits()));
}

◆ set_kernel_offset()

void dart::Class::set_kernel_offset ( intptr_t value ) const

inline

Definition at line 1814 of file object.h.

                                               {
#if defined(DART_PRECOMPILED_RUNTIME)
    UNREACHABLE();
#else
    ASSERT(value >= 0);
    StoreNonPointer(&untag()->kernel_offset_, value);
#endif
  }

◆ set_library()

void dart::Class::set_library ( const Library & value ) const

Definition at line 3488 of file object.cc.

                                                  {
  untag()->set_library(value.ptr());
}

◆ set_next_field_offset()

void dart::Class::set_next_field_offset	(	intptr_t	host_value_in_bytes,
		intptr_t	target_value_in_bytes
	)		const

inline

Definition at line 1203 of file object.h.

                                                                   {
    set_next_field_offset_in_words(
        host_value_in_bytes / kCompressedWordSize,
        target_value_in_bytes / compiler::target::kCompressedWordSize);
  }

◆ set_next_field_offset_in_words()

void dart::Class::set_next_field_offset_in_words	(	intptr_t	host_value,
		intptr_t	target_value
	)		const

inline

Definition at line 1209 of file object.h.

                                                                   {
    // Assert that the next field offset is either negative (ie, this object
    // can't be extended by dart code), or rounds up to the kObjectAligned
    // instance size.
    ASSERT((host_value < 0) ||
           ((host_value <= untag()->host_instance_size_in_words_) &&
            (host_value + (kObjectAlignment / kCompressedWordSize) >
             untag()->host_instance_size_in_words_)));
    StoreNonPointer(&untag()->host_next_field_offset_in_words_, host_value);
#if defined(DART_PRECOMPILER)
    ASSERT((target_value < 0) ||
           ((target_value <= untag()->target_instance_size_in_words_) &&
            (target_value + (compiler::target::kObjectAlignment /
                             compiler::target::kCompressedWordSize) >
             untag()->target_instance_size_in_words_)));
    StoreNonPointer(&untag()->target_next_field_offset_in_words_, target_value);
#else
    // Could be different only during cross-compilation.
    ASSERT_EQUAL(host_value, target_value);
#endif  // defined(DART_PRECOMPILER)
  }

◆ set_num_native_fields()

void dart::Class::set_num_native_fields ( uint16_t value ) const

inline

Definition at line 1791 of file object.h.

                                                   {
    StoreNonPointer(&untag()->num_native_fields_, value);
  }

◆ set_num_type_arguments()

void dart::Class::set_num_type_arguments ( intptr_t value ) const

Definition at line 3170 of file object.cc.

                                                       {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  if (!Utils::IsInt(16, value)) {
    ReportTooManyTypeArguments(*this);
  }
  // We allow concurrent calculation of the number of type arguments. If two
  // threads perform this operation it doesn't matter which one wins.
  DEBUG_ONLY(intptr_t old_value = num_type_arguments());
  DEBUG_ASSERT(old_value == kUnknownNumTypeArguments || old_value == value);
  StoreNonPointer<int16_t, int16_t, std::memory_order_relaxed>(
      &untag()->num_type_arguments_, value);
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ set_num_type_arguments_unsafe()

void dart::Class::set_num_type_arguments_unsafe ( intptr_t value ) const

Definition at line 3186 of file object.cc.

                                                              {
  StoreNonPointer(&untag()->num_type_arguments_, value);
}

◆ set_script()

void dart::Class::set_script ( const Script & value ) const

Definition at line 5610 of file object.cc.

                                                {
  untag()->set_script(value.ptr());
}

◆ set_super_type()

void dart::Class::set_super_type ( const Type & value ) const

Definition at line 3734 of file object.cc.

                                                  {
  ASSERT(value.IsNull() || !value.IsDynamicType());
  untag()->set_super_type(value.ptr());
}

◆ set_token_pos()

void dart::Class::set_token_pos ( TokenPosition value ) const

Definition at line 5620 of file object.cc.

                                                       {
  ASSERT(!token_pos.IsClassifying());
  StoreNonPointer(&untag()->token_pos_, token_pos);
}

◆ set_type_arguments_field_offset()

void dart::Class::set_type_arguments_field_offset	(	intptr_t	host_value_in_bytes,
		intptr_t	target_value_in_bytes
	)		const

inline

Definition at line 1399 of file object.h.

                                                                             {
    intptr_t host_value, target_value;
    if (host_value_in_bytes == kNoTypeArguments ||
        target_value_in_bytes == RTN::Class::kNoTypeArguments) {
      ASSERT(host_value_in_bytes == kNoTypeArguments &&
             target_value_in_bytes == RTN::Class::kNoTypeArguments);
      host_value = kNoTypeArguments;
      target_value = RTN::Class::kNoTypeArguments;
    } else {
      ASSERT(kCompressedWordSize != 0 && compiler::target::kCompressedWordSize);
      host_value = host_value_in_bytes / kCompressedWordSize;
      target_value =
          target_value_in_bytes / compiler::target::kCompressedWordSize;
    }
    set_type_arguments_field_offset_in_words(host_value, target_value);
  }

◆ set_type_arguments_field_offset_in_words()

void dart::Class::set_type_arguments_field_offset_in_words	(	intptr_t	host_value,
		intptr_t	target_value
	)		const

inline

Definition at line 1416 of file object.h.

                                                                             {
    StoreNonPointer(&untag()->host_type_arguments_field_offset_in_words_,
                    host_value);
#if defined(DART_PRECOMPILER)
    StoreNonPointer(&untag()->target_type_arguments_field_offset_in_words_,
                    target_value);
#else
    // Could be different only during cross-compilation.
    ASSERT_EQUAL(host_value, target_value);
#endif  // defined(DART_PRECOMPILER)
  }

◆ set_type_parameters()

void dart::Class::set_type_parameters ( const TypeParameters & value ) const

Definition at line 3492 of file object.cc.

                                                                 {
  ASSERT((num_type_arguments() == kUnknownNumTypeArguments) ||
         is_prefinalized());
  untag()->set_type_parameters(value.ptr());
}

◆ SetFields()

void dart::Class::SetFields ( const Array & value ) const

Definition at line 5039 of file object.cc.

                                              {
  ASSERT(!value.IsNull());
#if defined(DEBUG)
  Thread* thread = Thread::Current();
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
  // Verify that all the fields in the array have this class as owner.
  Field& field = Field::Handle();
  intptr_t len = value.Length();
  for (intptr_t i = 0; i < len; i++) {
    field ^= value.At(i);
    ASSERT(field.IsOriginal());
    ASSERT(field.Owner() == ptr());
  }
#endif
  // The value of static fields is already initialized to null.
  set_fields(value);
}

◆ SetFunctions()

void dart::Class::SetFunctions ( const Array & value ) const

Definition at line 3314 of file object.cc.

                                                 {
  ASSERT(!value.IsNull());
  const intptr_t len = value.Length();
#if defined(DEBUG)
  Thread* thread = Thread::Current();
  ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
  if (is_finalized()) {
    Function& function = Function::Handle();
    FunctionType& signature = FunctionType::Handle();
    for (intptr_t i = 0; i < len; ++i) {
      function ^= value.At(i);
      signature = function.signature();
      ASSERT(signature.IsFinalized());
    }
  }
#endif
  set_functions(value);
  if (len >= kFunctionLookupHashThreshold) {
    ClassFunctionsSet set(HashTables::New<ClassFunctionsSet>(len, Heap::kOld));
    Function& func = Function::Handle();
    for (intptr_t i = 0; i < len; ++i) {
      func ^= value.At(i);
      // Verify that all the functions in the array have this class as owner.
      ASSERT(func.Owner() == ptr());
      set.Insert(func);
    }
    untag()->set_functions_hash_table(set.Release().ptr());
  } else {
    untag()->set_functions_hash_table(Array::null());
  }
}

◆ SetTraceAllocation()

void dart::Class::SetTraceAllocation ( bool trace_allocation ) const

Definition at line 4498 of file object.cc.

                                                          {
#ifndef PRODUCT
  auto isolate_group = IsolateGroup::Current();
  const bool changed = trace_allocation != this->TraceAllocation(isolate_group);
  if (changed) {
    auto class_table = isolate_group->class_table();
    class_table->SetTraceAllocationFor(id(), trace_allocation);
#ifdef TARGET_ARCH_IA32
    DisableAllocationStub();
#endif
  }
#else
  UNREACHABLE();
#endif
}

◆ SetUserVisibleNameInClassTable()

void dart::Class::SetUserVisibleNameInClassTable ( )

Definition at line 5438 of file object.cc.

                                           {
  IsolateGroup* isolate_group = IsolateGroup::Current();
  auto class_table = isolate_group->class_table();
  if (class_table->UserVisibleNameFor(id()) == nullptr) {
    String& name = String::Handle(UserVisibleName());
    class_table->SetUserVisibleNameFor(id(), name.ToMallocCString());
  }
}

◆ SourceFingerprint()

int32_t dart::Class::SourceFingerprint ( ) const

Definition at line 5659 of file object.cc.

                                       {
#if !defined(DART_PRECOMPILED_RUNTIME)
  return kernel::KernelSourceFingerprintHelper::CalculateClassFingerprint(
      *this);
#else
  return 0;
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
}

◆ super_type()

TypePtr dart::Class::super_type ( ) const

inline

Definition at line 1433 of file object.h.

                             {
    ASSERT(is_declaration_loaded());
    return untag()->super_type();
  }

◆ super_type_offset()

static intptr_t dart::Class::super_type_offset ( )

inlinestatic

Definition at line 1438 of file object.h.

                                      {
    return OFFSET_OF(UntaggedClass, super_type_);
  }

◆ SuperClass()

ClassPtr dart::Class::SuperClass ( ClassTable * class_table = nullptr ) const

Definition at line 3715 of file object.cc.

                                                          {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  if (class_table == nullptr) {
    class_table = thread->isolate_group()->class_table();
  }
 
  if (super_type() == AbstractType::null()) {
    if (id() == kTypeArgumentsCid) {
      // Pretend TypeArguments objects are Dart instances.
      return class_table->At(kInstanceCid);
    }
    return Class::null();
  }
  const AbstractType& sup_type = AbstractType::Handle(zone, super_type());
  const intptr_t type_class_id = sup_type.type_class_id();
  return class_table->At(type_class_id);
}

◆ target_instance_size() [1/2]

intptr_t dart::Class::target_instance_size ( ) const

inline

Definition at line 1149 of file object.h.

                                        {
    ASSERT(is_finalized() || is_prefinalized());
#if defined(DART_PRECOMPILER)
    return (untag()->target_instance_size_in_words_ *
            compiler::target::kCompressedWordSize);
#else
    return host_instance_size();
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_instance_size() [2/2]

static intptr_t dart::Class::target_instance_size ( ClassPtr clazz )

inlinestatic

Definition at line 1161 of file object.h.

                                                       {
#if defined(DART_PRECOMPILER)
    return (clazz->untag()->target_instance_size_in_words_ *
            compiler::target::kCompressedWordSize);
#else
    return host_instance_size(clazz);
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_instance_size_in_words()

static int32_t dart::Class::target_instance_size_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1949 of file object.h.

                                                                   {
#if defined(DART_PRECOMPILER)
    return cls->untag()->target_instance_size_in_words_;
#else
    return host_instance_size_in_words(cls);
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_next_field_offset()

intptr_t dart::Class::target_next_field_offset ( ) const

inline

Definition at line 1195 of file object.h.

                                            {
#if defined(DART_PRECOMPILER)
    return untag()->target_next_field_offset_in_words_ *
           compiler::target::kCompressedWordSize;
#else
    return host_next_field_offset();
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_next_field_offset_in_words()

static int32_t dart::Class::target_next_field_offset_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1961 of file object.h.

                                                                       {
#if defined(DART_PRECOMPILER)
    return cls->untag()->target_next_field_offset_in_words_;
#else
    return host_next_field_offset_in_words(cls);
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_type_arguments_field_offset()

intptr_t dart::Class::target_type_arguments_field_offset ( ) const

inline

Definition at line 1386 of file object.h.

                                                      {
#if defined(DART_PRECOMPILER)
    ASSERT(is_type_finalized() || is_prefinalized());
    if (untag()->target_type_arguments_field_offset_in_words_ ==
        compiler::target::Class::kNoTypeArguments) {
      return compiler::target::Class::kNoTypeArguments;
    }
    return untag()->target_type_arguments_field_offset_in_words_ *
           compiler::target::kCompressedWordSize;
#else
    return host_type_arguments_field_offset();
#endif  // defined(DART_PRECOMPILER)
  }

◆ target_type_arguments_field_offset_in_words()

static int32_t dart::Class::target_type_arguments_field_offset_in_words ( const ClassPtr cls )

inlinestatic

Definition at line 1973 of file object.h.

                          {
#if defined(DART_PRECOMPILER)
    return cls->untag()->target_type_arguments_field_offset_in_words_;
#else
    return host_type_arguments_field_offset_in_words(cls);
#endif  // defined(DART_PRECOMPILER)
  }

◆ token_pos()

TokenPosition dart::Class::token_pos ( ) const

inline

Definition at line 1281 of file object.h.

                                  {
#if defined(DART_PRECOMPILED_RUNTIME)
    return TokenPosition::kNoSource;
#else
    return untag()->token_pos_;
#endif  // defined(DART_PRECOMPILED_RUNTIME)
  }

◆ TraceAllocation()

bool dart::Class::TraceAllocation ( IsolateGroup * isolate_group ) const

Definition at line 4489 of file object.cc.

                                                             {
#ifndef PRODUCT
  auto class_table = isolate_group->class_table();
  return class_table->ShouldTraceAllocationFor(id());
#else
  return false;
#endif
}

◆ type_parameters()

TypeParametersPtr dart::Class::type_parameters ( ) const

inline

Definition at line 1340 of file object.h.

                                            {
    ASSERT(is_declaration_loaded());
    return untag()->type_parameters();
  }

◆ TypeParameterAt()

TypeParameterPtr dart::Class::TypeParameterAt	(	intptr_t	index,
		Nullability	nullability = `Nullability::kNonNullable`
	)		const

Definition at line 3739 of file object.cc.

                                                                       {
  ASSERT(index >= 0 && index < NumTypeParameters());
  TypeParameter& type_param =
      TypeParameter::Handle(TypeParameter::New(*this, 0, index, nullability));
  // Finalize type parameter only if its declaring class is
  // finalized and available in the current class table.
  if (is_type_finalized() && (type_param.parameterized_class() == ptr())) {
    type_param ^= ClassFinalizer::FinalizeType(type_param);
  }
  return type_param.ptr();
}

◆ UnboxedFieldSizeInBytesByCid()

intptr_t dart::Class::UnboxedFieldSizeInBytesByCid ( intptr_t cid )

static

Definition at line 3752 of file object.cc.

                                                         {
  switch (cid) {
    case kDoubleCid:
      return sizeof(UntaggedDouble::value_);
    case kFloat32x4Cid:
      return sizeof(UntaggedFloat32x4::value_);
    case kFloat64x2Cid:
      return sizeof(UntaggedFloat64x2::value_);
    default:
      return sizeof(UntaggedMint::value_);
  }
}

◆ UserVisibleName()

StringPtr dart::Class::UserVisibleName ( ) const

Definition at line 3050 of file object.cc.

                                       {
#if !defined(PRODUCT)
  ASSERT(untag()->user_name() != String::null());
  return untag()->user_name();
#endif  // !defined(PRODUCT)
  // No caching in PRODUCT, regenerate.
  return Symbols::New(Thread::Current(), GenerateUserVisibleName());
}

◆ UserVisibleNameCString()

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

Definition at line 3059 of file object.cc.

                                                {
#if !defined(PRODUCT)
  ASSERT(untag()->user_name() != String::null());
  return String::Handle(untag()->user_name()).ToCString();
#endif                               // !defined(PRODUCT)
  return GenerateUserVisibleName();  // No caching in PRODUCT, regenerate.
}

◆ VerifyEntryPoint()

ErrorPtr dart::Class::VerifyEntryPoint ( ) const

Definition at line 27446 of file object.cc.

                                       {
  if (!FLAG_verify_entry_points) return Error::null();
  const Library& lib = Library::Handle(library());
  if (!lib.IsNull()) {
    return dart::VerifyEntryPoint(lib, *this, *this, {});
  } else {
    return Error::null();
  }
}

Friends And Related Symbol Documentation

◆ AbstractType

friend class AbstractType

friend

Definition at line 2217 of file object.h.

◆ ClassFinalizer

friend class ClassFinalizer

friend

Definition at line 2224 of file object.h.

◆ Instance

friend class Instance

friend

Definition at line 2218 of file object.h.

◆ Intrinsifier

friend class Intrinsifier

friend

Definition at line 2221 of file object.h.

◆ Object

friend class Object

friend

Definition at line 2219 of file object.h.

◆ Precompiler

friend class Precompiler

friend

Definition at line 2223 of file object.h.

◆ ProgramWalker

friend class ProgramWalker

friend

Definition at line 2222 of file object.h.

◆ Type

friend class Type

friend

Definition at line 2220 of file object.h.

Member Data Documentation

◆ kNoTypeArguments

constexpr intptr_t dart::Class::kNoTypeArguments = -1

staticconstexpr

Definition at line 1376 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
third_party/dart-lang/sdk/runtime/vm/object_reload.cc

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ InvocationDispatcherEntry

Member Function Documentation

◆ AddDirectImplementor()

◆ AddDirectSubclass()

◆ AddField()

◆ AddFields()

◆ AddFunction()

◆ AddInvocationDispatcher()

◆ allocation_stub()

◆ can_be_future()

◆ CheckReload()

◆ class_loading_state()

◆ constants()

◆ CopyCanonicalConstants()

◆ CopyDeclarationType()

◆ CopyStaticFieldValues()

◆ current_functions()

◆ declaration_type_offset()

◆ DeclarationType()

◆ DefaultTypeArguments()

◆ dependent_code()

◆ DictionaryName()

◆ direct_implementors()

◆ direct_implementors_unsafe()

◆ direct_subclasses()

◆ direct_subclasses_unsafe()

◆ DisableAllCHAOptimizedCode()

◆ DisableAllocationStub()

◆ DisableCHAImplementorUsers()

◆ DisableCHAOptimizedCode()

◆ end_token_pos()

◆ EnsureDeclarationLoaded()

◆ EnsureIsAllocateFinalized()

◆ EnsureIsFinalized()

◆ EvaluateCompiledExpression()

◆ FieldFromIndex()

◆ fields()

◆ Finalize()

◆ FindFieldIndex()

◆ FindFunctionIndex()

◆ FindImplicitClosureFunctionIndex()

◆ FindInstantiationOf() [1/4]

◆ FindInstantiationOf() [2/4]

◆ FindInstantiationOf() [3/4]

◆ FindInstantiationOf() [4/4]

◆ FindInvocationDispatcherFunctionIndex()

◆ FunctionFromIndex()

◆ functions()

◆ GetClassId()

◆ GetDeclarationInstanceTypeArguments()

◆ GetInstanceTypeArguments()

◆ GetInstantiationOf() [1/2]

◆ GetInstantiationOf() [2/2]

◆ GetInvocationDispatcher()

◆ GetRecordFieldGetter()

◆ has_pragma()

◆ HasCompressedPointers()

◆ Hash() [1/2]

◆ Hash() [2/2]

◆ HasInstanceFields()

◆ host_instance_size() [1/2]

◆ host_instance_size() [2/2]

◆ host_instance_size_in_words()

◆ host_next_field_offset()

◆ host_next_field_offset_in_words()

◆ host_type_arguments_field_offset()

◆ host_type_arguments_field_offset_in_words()

◆ host_type_arguments_field_offset_in_words_offset()

◆ id()

◆ id_offset()

◆ implementor_cid()

◆ ImplicitClosureFunctionFromIndex()