#include <object.h>

Inheritance diagram for dart::Function:

Classes
struct	AwaiterLink

struct	ICDataArrayIndices

class	KindBits

class	ModifierBits

class	RecognizedBits

Public Types
enum	StateBits

enum	KindTagBits { kKindTagPos = 0 , kKindTagSize = 5 , kRecognizedTagPos = kKindTagPos + kKindTagSize , kRecognizedTagSize = 9 , kModifierPos = kRecognizedTagPos + kRecognizedTagSize , kModifierSize = 2 , kLastModifierBitPos = kModifierPos + (kModifierSize - 1) , kNumTagBits }

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
StringPtr	name () const

StringPtr	UserVisibleName () const

const char *	UserVisibleNameCString () const

const char *	NameCString (NameVisibility name_visibility) const

void	PrintName (const NameFormattingParams &params, BaseTextBuffer *printer) const

StringPtr	QualifiedScrubbedName () const

const char *	QualifiedScrubbedNameCString () const

StringPtr	QualifiedUserVisibleName () const

const char *	QualifiedUserVisibleNameCString () const

virtual StringPtr	DictionaryName () const

StringPtr	GetSource () const

void	SetFfiCSignature (const FunctionType &sig) const

FunctionTypePtr	FfiCSignature () const

bool	FfiCSignatureContainsHandles () const

bool	FfiCSignatureReturnsStruct () const

int32_t	FfiCallbackId () const

void	AssignFfiCallbackId (int32_t callback_id) const

bool	FfiIsLeaf () const

FunctionPtr	FfiCallbackTarget () const

void	SetFfiCallbackTarget (const Function &target) const

InstancePtr	FfiCallbackExceptionalReturn () const

void	SetFfiCallbackExceptionalReturn (const Instance &value) const

FfiCallbackKind	GetFfiCallbackKind () const

void	SetFfiCallbackKind (FfiCallbackKind value) const

	PRECOMPILER_WSR_FIELD_DECLARATION (FunctionType, signature)

void	SetSignature (const FunctionType &value) const

StringPtr	InternalSignature () const

StringPtr	UserVisibleSignature () const

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

bool	IsPrivate () const

ClassPtr	Owner () const

void	set_owner (const Object &value) const

ScriptPtr	script () const

KernelProgramInfoPtr	KernelProgramInfo () const

ObjectPtr	RawOwner () const

RegExpPtr	regexp () const

intptr_t	string_specialization_cid () const

bool	is_sticky_specialization () const

void	SetRegExpData (const RegExp &regexp, intptr_t string_specialization_cid, bool sticky) const

StringPtr	native_name () const

void	set_native_name (const String &name) const

InstancePtr	GetNativeAnnotation () const

bool	is_ffi_native () const

bool	is_old_native () const

AbstractTypePtr	result_type () const

AbstractTypePtr	ParameterTypeAt (intptr_t index) const

ArrayPtr	parameter_types () const

StringPtr	ParameterNameAt (intptr_t index) const

void	SetParameterNameAt (intptr_t index, const String &value) const

void	CreateNameArray (Heap::Space space=Heap::kOld) const

bool	IsRequiredAt (intptr_t index) const

TypeParametersPtr	type_parameters () const

intptr_t	NumTypeParameters () const

intptr_t	NumParentTypeArguments () const

intptr_t	NumTypeArguments () const

bool	IsGeneric () const

bool	HasGenericParent () const

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

void	InstallOptimizedCode (const Code &code) const

void	AttachCode (const Code &value) const

void	SetInstructions (const Code &value) const

void	SetInstructionsSafe (const Code &value) const

void	ClearCode () const

void	ClearCodeSafe () const

void	SwitchToUnoptimizedCode () const

CodePtr	EnsureHasCode () const

void	SwitchToLazyCompiledUnoptimizedCode () const

void	EnsureHasCompiledUnoptimizedCode () const

CodePtr	CurrentCode () const

bool	SafeToClosurize () const

CodePtr	unoptimized_code () const

void	set_unoptimized_code (const Code &value) const

bool	HasCode () const

uword	entry_point () const

virtual uword	Hash () const

bool	HasBreakpoint () const

ContextScopePtr	context_scope () const

void	set_context_scope (const ContextScope &value) const

AwaiterLink	awaiter_link () const

void	set_awaiter_link (AwaiterLink link) const

bool	HasAwaiterLink () const

FunctionPtr	parent_function () const

TypeArgumentsPtr	DefaultTypeArguments (Zone *zone) const

InstantiationMode	default_type_arguments_instantiation_mode () const

void	set_default_type_arguments_instantiation_mode (InstantiationMode value) const

FunctionPtr	GetOutermostFunction () const

void	set_extracted_method_closure (const Function &function) const

FunctionPtr	extracted_method_closure () const

void	set_saved_args_desc (const Array &array) const

ArrayPtr	saved_args_desc () const

bool	HasSavedArgumentsDescriptor () const

void	set_accessor_field (const Field &value) const

FieldPtr	accessor_field () const

bool	IsRegularFunction () const

bool	IsMethodExtractor () const

bool	IsNoSuchMethodDispatcher () const

bool	IsRecordFieldGetter () const

bool	IsInvokeFieldDispatcher () const

bool	IsDynamicInvokeFieldDispatcher () const

bool	IsDynamicClosureCallDispatcher () const

bool	IsDynamicClosureCallDispatcher (Thread *thread) const

bool	IsDynamicInvocationForwarder () const

bool	IsImplicitGetterOrSetter () const

bool	HasImplicitClosureFunction () const

FunctionPtr	ImplicitClosureFunction () const

void	DropUncompiledImplicitClosureFunction () const

ClosurePtr	ImplicitStaticClosure () const

ClosurePtr	ImplicitInstanceClosure (const Instance &receiver) const

FunctionPtr	ImplicitClosureTarget (Zone *zone) const

FunctionPtr	ForwardingTarget () const

void	SetForwardingTarget (const Function &target) const

UntaggedFunction::Kind	kind () const

UntaggedFunction::AsyncModifier	modifier () const

bool	IsConstructor () const

bool	IsGenerativeConstructor () const

bool	IsImplicitConstructor () const

bool	IsFactory () const

bool	HasThisParameter () const

bool	IsDynamicFunction (bool allow_abstract=false) const

bool	IsStaticFunction () const

bool	NeedsTypeArgumentTypeChecks () const

bool	NeedsArgumentTypeChecks () const

bool	NeedsMonomorphicCheckedEntry (Zone *zone) const

bool	HasDynamicCallers (Zone *zone) const

bool	PrologueNeedsArgumentsDescriptor () const

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

intptr_t	SourceSize () const

uint32_t	packed_fields () const

void	set_packed_fields (uint32_t packed_fields) const

intptr_t	num_fixed_parameters () const

bool	HasOptionalParameters () const

bool	HasOptionalNamedParameters () const

bool	HasRequiredNamedParameters () const

bool	HasOptionalPositionalParameters () const

intptr_t	NumOptionalParameters () const

intptr_t	NumOptionalPositionalParameters () const

intptr_t	NumOptionalNamedParameters () const

intptr_t	NumParameters () const

intptr_t	NumImplicitParameters () const

bool	MakesCopyOfParameters () const

intptr_t	MaxNumberOfParametersInRegisters (Zone *zone) const

intptr_t	kernel_offset () const

void	set_kernel_offset (intptr_t value) const

void	InheritKernelOffsetFrom (const Function &src) const

void	InheritKernelOffsetFrom (const Field &src) const

void	SetOptimizedInstructionCountClamped (uintptr_t value) const

void	SetOptimizedCallSiteCountClamped (uintptr_t value) const

void	SetKernelLibraryAndEvalScript (const Script &script, const class KernelProgramInfo &kernel_program_info, intptr_t index) const

intptr_t	KernelLibraryOffset () const

intptr_t	KernelLibraryIndex () const

TypedDataViewPtr	KernelLibrary () const

bool	IsOptimizable () const

void	SetIsOptimizable (bool value) const

bool	ForceOptimize () const

bool	IsPreferInline () const

bool	IsIdempotent () const

bool	IsCachableIdempotent () const

bool	RecognizedKindForceOptimize () const

bool	CanBeInlined () const

MethodRecognizer::Kind	recognized_kind () const

void	set_recognized_kind (MethodRecognizer::Kind value) const

bool	IsRecognized () const

bool	HasOptimizedCode () const

bool	AreValidArgumentCounts (intptr_t num_type_arguments, intptr_t num_arguments, intptr_t num_named_arguments, String *error_message) const

ObjectPtr	DoArgumentTypesMatch (const Array &args, const ArgumentsDescriptor &arg_names) const

ObjectPtr	DoArgumentTypesMatch (const Array &args, const ArgumentsDescriptor &arg_names, const TypeArguments &instantiator_type_args) const

ObjectPtr	DoArgumentTypesMatch (const Array &args, const ArgumentsDescriptor &arg_names, const TypeArguments &instantiator_type_args, const TypeArguments &function_type_args) const

bool	AreValidArguments (intptr_t num_type_arguments, intptr_t num_arguments, const Array &argument_names, String *error_message) const

bool	AreValidArguments (const ArgumentsDescriptor &args_desc, String *error_message) const

const char *	ToFullyQualifiedCString () const

const char *	ToLibNamePrefixedQualifiedCString () const

const char *	ToQualifiedCString () const

void	reset_unboxed_parameters_and_return () const

void	set_unboxed_integer_parameter_at (intptr_t index) const

void	set_unboxed_double_parameter_at (intptr_t index) const

void	set_unboxed_integer_return () const

void	set_unboxed_double_return () const

void	set_unboxed_record_return () const

bool	is_unboxed_parameter_at (intptr_t index) const

bool	is_unboxed_integer_parameter_at (intptr_t index) const

bool	is_unboxed_double_parameter_at (intptr_t index) const

bool	has_unboxed_return () const

bool	has_unboxed_integer_return () const

bool	has_unboxed_double_return () const

bool	has_unboxed_record_return () const

bool	HasUnboxedParameters () const

bool	HasUnboxedReturnValue () const

bool	IsDispatcherOrImplicitAccessor () const

bool	IsGetterFunction () const

bool	IsImplicitGetterFunction () const

bool	IsImplicitStaticGetterFunction () const

bool	IsSetterFunction () const

bool	IsImplicitSetterFunction () const

bool	IsFieldInitializer () const

bool	IsClosureFunction () const

bool	IsIrregexpFunction () const

bool	IsImplicitClosureFunction () const

bool	IsNonImplicitClosureFunction () const

bool	IsImplicitStaticClosureFunction () const

bool	IsImplicitInstanceClosureFunction () const

bool	HasParent () const

bool	IsLocalFunction () const

bool	IsFfiCallbackTrampoline () const

bool	IsFfiCallClosure () const

InstancePtr	GetFfiCallClosurePragmaValue () const

bool	IsSuspendableFunction () const

bool	IsAsyncFunction () const

bool	IsSyncGenerator () const

bool	IsAsyncGenerator () const

bool	IsTypedDataViewFactory () const

bool	IsUnmodifiableTypedDataViewFactory () const

DART_WARN_UNUSED_RESULT ErrorPtr	VerifyCallEntryPoint () const

DART_WARN_UNUSED_RESULT ErrorPtr	VerifyClosurizedEntryPoint () const

FunctionPtr	CreateMethodExtractor (const String &getter_name) const

FunctionPtr	GetMethodExtractor (const String &getter_name) const

FunctionPtr	CreateDynamicInvocationForwarder (const String &mangled_name) const

FunctionPtr	GetDynamicInvocationForwarder (const String &mangled_name, bool allow_add=true) const

int32_t	SourceFingerprint () const

bool	CheckSourceFingerprint (int32_t fp, const char *kind=nullptr) const

void	SaveICDataMap (const ZoneGrowableArray< const ICData * > &deopt_id_to_ic_data, const Array &edge_counters_array, const Array &coverage_array) const

void	RestoreICDataMap (ZoneGrowableArray< const ICData * > *deopt_id_to_ic_data, bool clone_ic_data) const

ArrayPtr	ic_data_array () const

void	ClearICDataArray () const

ICDataPtr	FindICData (intptr_t deopt_id) const

ArrayPtr	GetCoverageArray () const

void	AddFunctionServiceId (const JSONObject &obj) const

void	SetDeoptReasonForAll (intptr_t deopt_id, ICData::DeoptReasonId reason)

void	set_modifier (UntaggedFunction::AsyncModifier value) const

void	SetUsageCounter (intptr_t value) const

bool	WasExecuted () const

void	SetWasExecuted (bool value) const

bool	is_optimizable () const

void	set_is_optimizable (bool value) const

	COMPILE_ASSERT (MethodRecognizer::kNumRecognizedMethods<(1<< kRecognizedTagSize))

	COMPILE_ASSERT (kNumTagBits<=(kBitsPerByte *sizeof(decltype(UntaggedFunction::kind_tag_))))

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	signature_offset ()

static CodePtr	CurrentCodeOf (const FunctionPtr function)

static bool	HasCode (FunctionPtr function)

static intptr_t	code_offset ()

static uword	EntryPointOf (const FunctionPtr function)

static intptr_t	entry_point_offset (CodeEntryKind entry_kind=CodeEntryKind::kNormal)

static intptr_t	unchecked_entry_point_offset ()

static UntaggedFunction::Kind	KindOf (FunctionPtr func)

static const char *	KindToCString (UntaggedFunction::Kind kind)

static constexpr intptr_t	maximum_unboxed_parameter_count ()

static bool	IsImplicitClosureFunction (FunctionPtr func)

static bool	IsImplicitStaticClosureFunction (FunctionPtr func)

static bool	IsImplicitInstanceClosureFunction (FunctionPtr func)

static bool	IsFfiCallbackTrampoline (FunctionPtr function)

static intptr_t	InstanceSize ()

static FunctionPtr	New (const FunctionType &signature, const String &name, UntaggedFunction::Kind kind, bool is_static, bool is_const, bool is_abstract, bool is_external, bool is_native, const Object &owner, TokenPosition token_pos, Heap::Space space=Heap::kOld)

static FunctionPtr	NewClosureFunctionWithKind (UntaggedFunction::Kind kind, const String &name, const Function &parent, bool is_static, TokenPosition token_pos, const Object &owner)

static FunctionPtr	NewClosureFunction (const String &name, const Function &parent, TokenPosition token_pos)

static FunctionPtr	NewImplicitClosureFunction (const String &name, const Function &parent, TokenPosition token_pos)

static bool	IsDynamicInvocationForwarderName (const String &name)

static bool	IsDynamicInvocationForwarderName (StringPtr name)

static StringPtr	DemangleDynamicInvocationForwarderName (const String &name)

static StringPtr	CreateDynamicInvocationForwarderName (const String &name)

static intptr_t	data_offset ()

static intptr_t	kind_tag_offset ()

static bool	is_visible (FunctionPtr f)

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	kMaxInstructionCount = (1 << 16) - 1

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

static const ClassId	kClassId = kObjectCid

Friends
class	Class

class	Parser

class	UntaggedFunction

class	ClassFinalizer

class	Type

class	Precompiler

class	ProgramVisitor

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

Member Enumeration Documentation

◆ KindTagBits

enum dart::Function::KindTagBits

Enumerator
kKindTagPos
kKindTagSize
kRecognizedTagPos
kRecognizedTagSize
kModifierPos
kModifierSize
kLastModifierBitPos
kNumTagBits

Definition at line 4194 of file object.h.

                   {
    kKindTagPos = 0,
    kKindTagSize = 5,
    kRecognizedTagPos = kKindTagPos + kKindTagSize,
    kRecognizedTagSize = 9,
    kModifierPos = kRecognizedTagPos + kRecognizedTagSize,
    kModifierSize = 2,
    kLastModifierBitPos = kModifierPos + (kModifierSize - 1),
// Single bit sized fields start here.
#define DECLARE_BIT(name, _) k##name##Bit,
    FOR_EACH_FUNCTION_KIND_BIT(DECLARE_BIT)
        FOR_EACH_FUNCTION_VOLATILE_KIND_BIT(DECLARE_BIT)
#undef DECLARE_BIT
            kNumTagBits
  };

◆ StateBits

enum dart::Function::StateBits

Definition at line 4075 of file object.h.

                 {
#define DECLARE_FLAG_POS(Name) k##Name##Pos,
    STATE_BITS_LIST(DECLARE_FLAG_POS)
#undef DECLARE_FLAG_POS
  };

Member Function Documentation

◆ accessor_field()

FieldPtr dart::Function::accessor_field ( ) const

Definition at line 8207 of file object.cc.

                                        {
  ASSERT(kind() == UntaggedFunction::kImplicitGetter ||
         kind() == UntaggedFunction::kImplicitSetter ||
         kind() == UntaggedFunction::kImplicitStaticGetter ||
         kind() == UntaggedFunction::kFieldInitializer);
  return Field::RawCast(untag()->data());
}

◆ AddFunctionServiceId()

void dart::Function::AddFunctionServiceId ( const JSONObject & obj ) const

Definition at line 280 of file object_service.cc.

                                                                 {
  Class& cls = Class::Handle(Owner());
  // Special kinds of functions use indices in their respective lists.
  intptr_t id = -1;
  const char* selector = nullptr;
  // Regular functions known to their owner use their name (percent-encoded).
  String& name = String::Handle(this->name());
 
  if (IsNonImplicitClosureFunction()) {
    id = ClosureFunctionsCache::FindClosureIndex(*this);
    selector = "closures";
  } else if (IsImplicitClosureFunction()) {
    id = cls.FindImplicitClosureFunctionIndex(*this);
    selector = "implicit_closures";
  } else if (IsNoSuchMethodDispatcher() || IsInvokeFieldDispatcher()) {
    id = cls.FindInvocationDispatcherFunctionIndex(*this);
    selector = "dispatchers";
  } else if (IsFieldInitializer()) {
    name ^= Field::NameFromInit(name);
    const char* encoded_field_name = String::EncodeIRI(name);
    if (cls.IsTopLevel()) {
      const auto& library = Library::Handle(cls.library());
      const auto& private_key = String::Handle(library.private_key());
      jsobj.AddFixedServiceId("libraries/%s/field_inits/%s",
                              private_key.ToCString(), encoded_field_name);
    } else {
      jsobj.AddFixedServiceId("classes/%" Pd "/field_inits/%s", cls.id(),
                              encoded_field_name);
    }
    return;
  }
  if (id != -1) {
    ASSERT(selector != nullptr);
    if (cls.IsTopLevel()) {
      const auto& library = Library::Handle(cls.library());
      const auto& private_key = String::Handle(library.private_key());
      jsobj.AddFixedServiceId("libraries/%s/%s/%" Pd "",
                              private_key.ToCString(), selector, id);
    } else {
      jsobj.AddFixedServiceId("classes/%" Pd "/%s/%" Pd "", cls.id(), selector,
                              id);
    }
    return;
  }
  Thread* thread = Thread::Current();
  if (Resolver::ResolveFunction(thread->zone(), cls, name) == ptr()) {
    const char* encoded_name = String::EncodeIRI(name);
    if (cls.IsTopLevel()) {
      const auto& library = Library::Handle(cls.library());
      const auto& private_key = String::Handle(library.private_key());
      jsobj.AddFixedServiceId("libraries/%s/functions/%s",
                              private_key.ToCString(), encoded_name);
    } else {
      jsobj.AddFixedServiceId("classes/%" Pd "/functions/%s", cls.id(),
                              encoded_name);
    }
    return;
  }
  // Oddball functions (not known to their owner) fall back to use the object
  // id ring. Current known examples are signature functions of closures
  // and stubs like 'megamorphic_call_miss'.
  jsobj.AddServiceId(*this);
}

◆ AreValidArgumentCounts()

bool dart::Function::AreValidArgumentCounts	(	intptr_t	num_type_arguments,
		intptr_t	num_arguments,
		intptr_t	num_named_arguments,
		String *	error_message
	)		const

Definition at line 9308 of file object.cc.

                                                                   {
  if ((num_type_arguments != 0) &&
      (num_type_arguments != NumTypeParameters())) {
    if (error_message != nullptr) {
      const intptr_t kMessageBufferSize = 64;
      char message_buffer[kMessageBufferSize];
      Utils::SNPrint(message_buffer, kMessageBufferSize,
                     "%" Pd " type arguments passed, but %" Pd " expected",
                     num_type_arguments, NumTypeParameters());
      // Allocate in old space because it can be invoked in background
      // optimizing compilation.
      *error_message = String::New(message_buffer, Heap::kOld);
    }
    return false;  // Too many type arguments.
  }
  if (num_named_arguments > NumOptionalNamedParameters()) {
    if (error_message != nullptr) {
      const intptr_t kMessageBufferSize = 64;
      char message_buffer[kMessageBufferSize];
      Utils::SNPrint(message_buffer, kMessageBufferSize,
                     "%" Pd " named passed, at most %" Pd " expected",
                     num_named_arguments, NumOptionalNamedParameters());
      // Allocate in old space because it can be invoked in background
      // optimizing compilation.
      *error_message = String::New(message_buffer, Heap::kOld);
    }
    return false;  // Too many named arguments.
  }
  const intptr_t num_pos_args = num_arguments - num_named_arguments;
  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
  const intptr_t num_pos_params = num_fixed_parameters() + num_opt_pos_params;
  if (num_pos_args > num_pos_params) {
    if (error_message != nullptr) {
      const intptr_t kMessageBufferSize = 64;
      char message_buffer[kMessageBufferSize];
      // Hide implicit parameters to the user.
      const intptr_t num_hidden_params = NumImplicitParameters();
      Utils::SNPrint(message_buffer, kMessageBufferSize,
                     "%" Pd "%s passed, %s%" Pd " expected",
                     num_pos_args - num_hidden_params,
                     num_opt_pos_params > 0 ? " positional" : "",
                     num_opt_pos_params > 0 ? "at most " : "",
                     num_pos_params - num_hidden_params);
      // Allocate in old space because it can be invoked in background
      // optimizing compilation.
      *error_message = String::New(message_buffer, Heap::kOld);
    }
    return false;  // Too many fixed and/or positional arguments.
  }
  if (num_pos_args < num_fixed_parameters()) {
    if (error_message != nullptr) {
      const intptr_t kMessageBufferSize = 64;
      char message_buffer[kMessageBufferSize];
      // Hide implicit parameters to the user.
      const intptr_t num_hidden_params = NumImplicitParameters();
      Utils::SNPrint(message_buffer, kMessageBufferSize,
                     "%" Pd "%s passed, %s%" Pd " expected",
                     num_pos_args - num_hidden_params,
                     num_opt_pos_params > 0 ? " positional" : "",
                     num_opt_pos_params > 0 ? "at least " : "",
                     num_fixed_parameters() - num_hidden_params);
      // Allocate in old space because it can be invoked in background
      // optimizing compilation.
      *error_message = String::New(message_buffer, Heap::kOld);
    }
    return false;  // Too few fixed and/or positional arguments.
  }
  return true;
}

◆ AreValidArguments() [1/2]

bool dart::Function::AreValidArguments	(	const ArgumentsDescriptor &	args_desc,
		String *	error_message
	)		const

Definition at line 9391 of file object.cc.

                                                              {
  const intptr_t num_type_arguments = args_desc.TypeArgsLen();
  const intptr_t num_arguments = args_desc.Count();
  const intptr_t num_named_arguments = args_desc.NamedCount();
 
  if (!AreValidArgumentCounts(num_type_arguments, num_arguments,
                              num_named_arguments, error_message)) {
    return false;
  }
  // Verify that all argument names are valid parameter names.
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  String& argument_name = String::Handle(zone);
  String& parameter_name = String::Handle(zone);
  const intptr_t num_positional_args = num_arguments - num_named_arguments;
  const intptr_t num_parameters = NumParameters();
  for (intptr_t i = 0; i < num_named_arguments; i++) {
    argument_name = args_desc.NameAt(i);
    ASSERT(argument_name.IsSymbol());
    bool found = false;
    for (intptr_t j = num_positional_args; j < num_parameters; j++) {
      parameter_name = ParameterNameAt(j);
      ASSERT(parameter_name.IsSymbol());
      if (argument_name.Equals(parameter_name)) {
        found = true;
        break;
      }
    }
    if (!found) {
      if (error_message != nullptr) {
        const intptr_t kMessageBufferSize = 64;
        char message_buffer[kMessageBufferSize];
        Utils::SNPrint(message_buffer, kMessageBufferSize,
                       "no optional formal parameter named '%s'",
                       argument_name.ToCString());
        *error_message = String::New(message_buffer);
      }
      return false;
    }
  }
  // Verify that all required named parameters are filled.
  for (intptr_t j = num_parameters - NumOptionalNamedParameters();
       j < num_parameters; j++) {
    if (IsRequiredAt(j)) {
      parameter_name = ParameterNameAt(j);
      ASSERT(parameter_name.IsSymbol());
      bool found = false;
      for (intptr_t i = 0; i < num_named_arguments; i++) {
        argument_name = args_desc.NameAt(i);
        ASSERT(argument_name.IsSymbol());
        if (argument_name.Equals(parameter_name)) {
          found = true;
          break;
        }
      }
      if (!found) {
        if (error_message != nullptr) {
          const intptr_t kMessageBufferSize = 64;
          char message_buffer[kMessageBufferSize];
          Utils::SNPrint(message_buffer, kMessageBufferSize,
                         "missing required named parameter '%s'",
                         parameter_name.ToCString());
          *error_message = String::New(message_buffer);
        }
        return false;
      }
    }
  }
  return true;
}

◆ AreValidArguments() [2/2]

bool dart::Function::AreValidArguments	(	intptr_t	num_type_arguments,
		intptr_t	num_arguments,
		const Array &	argument_names,
		String *	error_message
	)		const

Definition at line 9381 of file object.cc.

                                                              {
  const Array& args_desc_array = Array::Handle(ArgumentsDescriptor::NewBoxed(
      num_type_arguments, num_arguments, argument_names, Heap::kNew));
  ArgumentsDescriptor args_desc(args_desc_array);
  return AreValidArguments(args_desc, error_message);
}

◆ AssignFfiCallbackId()

void dart::Function::AssignFfiCallbackId ( int32_t callback_id ) const

Definition at line 8402 of file object.cc.

                                                            {
  ASSERT(IsFfiCallbackTrampoline());
 
  const auto& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  const auto& trampoline_data = FfiTrampolineData::Cast(obj);
 
  ASSERT(trampoline_data.callback_id() == -1);
  trampoline_data.set_callback_id(callback_id);
}

◆ AttachCode()

void dart::Function::AttachCode ( const Code & value ) const

Definition at line 7985 of file object.cc.

                                                 {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  // Finish setting up code before activating it.
  value.set_owner(*this);
  SetInstructions(value);
  ASSERT(Function::Handle(value.function()).IsNull() ||
         (value.function() == this->ptr()));
}

◆ awaiter_link()

Function::AwaiterLink dart::Function::awaiter_link ( ) const

Definition at line 8125 of file object.cc.

                                                 {
  if (IsClosureFunction()) {
    const Object& obj = Object::Handle(untag()->data());
    ASSERT(!obj.IsNull());
    return ClosureData::Cast(obj).awaiter_link();
  }
  UNREACHABLE();
  return {};
}

◆ CanBeInlined()

bool dart::Function::CanBeInlined ( ) const

Definition at line 9257 of file object.cc.

                                  {
  if (ForceOptimize()) {
    if (IsFfiCallClosure() || IsFfiCallbackTrampoline() || is_ffi_native()) {
      // We currently don't support inlining FFI trampolines. Some of them
      // are naturally non-inlinable because they contain a try/catch block,
      // but this condition is broader than strictly necessary.
      // The work necessary for inlining FFI trampolines is tracked by
      // http://dartbug.com/45055.
      return false;
    }
    if (CompilerState::Current().is_aot()) {
      return true;
    }
    // Inlining of force-optimized functions requires target function to be
    // idempotent becase if deoptimization is needed in inlined body, the
    // execution of the force-optimized will be restarted at the beginning of
    // the function.
    ASSERT(!IsPreferInline() || IsIdempotent());
    return IsIdempotent();
  }
 
  if (HasBreakpoint()) {
    return false;
  }
 
  return is_inlinable();
}

◆ CheckSourceFingerprint()

bool dart::Function::CheckSourceFingerprint	(	int32_t	fp,
		const char *	kind = `nullptr`
	)		const

Definition at line 11362 of file object.cc.

                                                                        {
#if !defined(DEBUG)
  return true;  // Only check on debug.
#endif
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  // Check that the function is marked as recognized via the vm:recognized
  // pragma. This is so that optimizations that change the signature will know
  // not to touch it.
  if (kind != nullptr && !MethodRecognizer::IsMarkedAsRecognized(*this, kind)) {
    OS::PrintErr(
        "Recognized method %s should be marked with: "
        "@pragma(\"vm:recognized\", \"%s\")\n",
        ToQualifiedCString(), kind);
    return false;
  }
#endif
 
  if (IsolateGroup::Current()->obfuscate() || FLAG_precompiled_mode ||
      (Dart::vm_snapshot_kind() != Snapshot::kNone)) {
    return true;  // The kernel structure has been altered, skip checking.
  }
 
  if (SourceFingerprint() != fp) {
    // This output can be copied into a file, then used with sed
    // to replace the old values.
    // sed -i.bak -f /tmp/newkeys \
    //    runtime/vm/compiler/recognized_methods_list.h
    THR_Print("s/0x%08x/0x%08x/\n", fp, SourceFingerprint());
    return false;
  }
  return true;
}

◆ ClearCode()

void dart::Function::ClearCode ( ) const

Definition at line 8006 of file object.cc.

                               {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  untag()->set_unoptimized_code(Code::null());
  SetInstructions(StubCode::LazyCompile());
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ ClearCodeSafe()

void dart::Function::ClearCodeSafe ( ) const

Definition at line 8016 of file object.cc.

                                   {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  untag()->set_unoptimized_code(Code::null());
 
  SetInstructionsSafe(StubCode::LazyCompile());
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ ClearICDataArray()

void dart::Function::ClearICDataArray ( ) const

Definition at line 11334 of file object.cc.

                                      {
  set_ic_data_array(Array::null_array());
}

◆ code_offset()

static intptr_t dart::Function::code_offset ( )

inlinestatic

Definition at line 3176 of file object.h.

3176{ return OFFSET_OF(UntaggedFunction, code_); }

dart::Function::UntaggedFunction

friend class UntaggedFunction

Definition object.h:4285

OFFSET_OF

#define OFFSET_OF(type, field)

Definition globals.h:138

◆ COMPILE_ASSERT() [1/2]

dart::Function::COMPILE_ASSERT ( kNumTagBits<= kBitsPerByte *sizeof(decltype(UntaggedFunction::kind_tag_)) )

◆ COMPILE_ASSERT() [2/2]

dart::Function::COMPILE_ASSERT ( )

◆ context_scope()

ContextScopePtr dart::Function::context_scope ( ) const

Definition at line 8106 of file object.cc.

                                              {
  if (IsClosureFunction()) {
    const Object& obj = Object::Handle(untag()->data());
    ASSERT(!obj.IsNull());
    return ClosureData::Cast(obj).context_scope();
  }
  return ContextScope::null();
}

◆ CreateDynamicInvocationForwarder()

FunctionPtr dart::Function::CreateDynamicInvocationForwarder ( const String & mangled_name ) const

Definition at line 4260 of file object.cc.

                                      {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  Function& forwarder = Function::Handle(zone);
  forwarder ^= Object::Clone(*this, Heap::kOld);
 
  forwarder.reset_unboxed_parameters_and_return();
 
  forwarder.set_name(mangled_name);
  forwarder.set_is_native(false);
  // TODO(dartbug.com/37737): Currently, we intentionally keep the recognized
  // kind when creating the dynamic invocation forwarder.
  forwarder.set_kind(UntaggedFunction::kDynamicInvocationForwarder);
  forwarder.set_modifier(UntaggedFunction::kNoModifier);
  forwarder.set_is_debuggable(false);
 
  // TODO(vegorov) for error reporting reasons it is better to make this
  // function visible and instead use a TailCall to invoke the target.
  // Our TailCall instruction is not ready for such usage though it
  // blocks inlining and can't take Function-s only Code objects.
  forwarder.set_is_visible(false);
 
  forwarder.ClearICDataArray();
  forwarder.ClearCode();
  forwarder.set_usage_counter(0);
  forwarder.set_deoptimization_counter(0);
  forwarder.set_optimized_instruction_count(0);
  forwarder.set_inlining_depth(0);
  forwarder.set_optimized_call_site_count(0);
 
  forwarder.InheritKernelOffsetFrom(*this);
  forwarder.SetForwardingTarget(*this);
 
  return forwarder.ptr();
}

◆ CreateDynamicInvocationForwarderName()

StringPtr dart::Function::CreateDynamicInvocationForwarderName ( const String & name )

static

Definition at line 4255 of file object.cc.

                                                                           {
  return Symbols::FromConcat(Thread::Current(), Symbols::DynamicPrefix(), name);
}

◆ CreateMethodExtractor()

FunctionPtr dart::Function::CreateMethodExtractor ( const String & getter_name ) const

Definition at line 4017 of file object.cc.

                                                                           {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  ASSERT(Field::IsGetterName(getter_name));
  const Function& closure_function =
      Function::Handle(zone, ImplicitClosureFunction());
 
  const Class& owner = Class::Handle(zone, closure_function.Owner());
  FunctionType& signature = FunctionType::Handle(zone, FunctionType::New());
  const Function& extractor = Function::Handle(
      zone,
      Function::New(signature,
                    String::Handle(zone, Symbols::New(thread, getter_name)),
                    UntaggedFunction::kMethodExtractor,
                    false,  // Not static.
                    false,  // Not const.
                    is_abstract(),
                    false,  // Not external.
                    false,  // Not native.
                    owner, TokenPosition::kMethodExtractor));
 
  // Initialize signature: receiver is a single fixed parameter.
  const intptr_t kNumParameters = 1;
  signature.set_num_fixed_parameters(kNumParameters);
  signature.SetNumOptionalParameters(0, false);
  signature.set_parameter_types(Object::synthetic_getter_parameter_types());
#if !defined(DART_PRECOMPILED_RUNTIME)
  extractor.set_positional_parameter_names(
      Object::synthetic_getter_parameter_names());
#endif
  signature.set_result_type(Object::dynamic_type());
 
  extractor.InheritKernelOffsetFrom(*this);
 
  extractor.set_extracted_method_closure(closure_function);
  extractor.set_is_debuggable(false);
  extractor.set_is_visible(false);
 
  signature ^= ClassFinalizer::FinalizeType(signature);
  extractor.SetSignature(signature);
 
  owner.AddFunction(extractor);
 
  return extractor.ptr();
}

◆ CreateNameArray()

void dart::Function::CreateNameArray ( Heap::Space space = Heap::kOld ) const

Definition at line 8735 of file object.cc.

                                                    {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  const intptr_t num_positional_params =
      num_fixed_parameters() + NumOptionalPositionalParameters();
  if (num_positional_params == 0) {
    set_positional_parameter_names(Object::empty_array());
  } else {
    set_positional_parameter_names(
        Array::Handle(Array::New(num_positional_params, space)));
  }
#endif
}

◆ CurrentCode()

CodePtr dart::Function::CurrentCode ( ) const

inline

Definition at line 3157 of file object.h.

3157{ return CurrentCodeOf(ptr()); }

dart::Function::CurrentCodeOf

static CodePtr CurrentCodeOf(const FunctionPtr function)

Definition object.h:3161

◆ CurrentCodeOf()

static CodePtr dart::Function::CurrentCodeOf ( const FunctionPtr function )

inlinestatic

Definition at line 3161 of file object.h.

                                                           {
    return function->untag()->code();
  }

◆ data_offset()

static intptr_t dart::Function::data_offset ( )

inlinestatic

Definition at line 4104 of file object.h.

4104{ return OFFSET_OF(UntaggedFunction, data_); }

◆ default_type_arguments_instantiation_mode()

InstantiationMode dart::Function::default_type_arguments_instantiation_mode ( ) const

Definition at line 8246 of file object.cc.

                                                                            {
  if (!IsClosureFunction()) {
    UNREACHABLE();
  }
  return ClosureData::DefaultTypeArgumentsInstantiationMode(
      ClosureData::RawCast(data()));
}

◆ DefaultTypeArguments()

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

Definition at line 8239 of file object.cc.

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

◆ DemangleDynamicInvocationForwarderName()

StringPtr dart::Function::DemangleDynamicInvocationForwarderName ( const String & name )

static

Definition at line 4248 of file object.cc.

                                                                             {
  const intptr_t kDynamicPrefixLength = 4;  // "dyn:"
  ASSERT(Symbols::DynamicPrefix().Length() == kDynamicPrefixLength);
  return Symbols::New(Thread::Current(), name, kDynamicPrefixLength,
                      name.Length() - kDynamicPrefixLength);
}

◆ DictionaryName()

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

inlinevirtual

Reimplemented from dart::Object.

Definition at line 2985 of file object.h.

2985{ return name(); }

◆ DoArgumentTypesMatch() [1/3]

ObjectPtr dart::Function::DoArgumentTypesMatch	(	const Array &	args,
		const ArgumentsDescriptor &	arg_names
	)		const

Definition at line 9563 of file object.cc.

                                                {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Precompiler deleted signature because of missing entry point pragma.
    return EntryPointMemberInvocationError(*this);
  }
#endif
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  auto& receiver = Instance::Handle(zone);
  if (IsClosureFunction() || HasThisParameter()) {
    receiver ^= args.At(args_desc.FirstArgIndex());
  }
  const auto& instantiator_type_arguments = TypeArguments::Handle(
      zone, RetrieveInstantiatorTypeArguments(zone, *this, receiver));
  return Function::DoArgumentTypesMatch(args, args_desc,
                                        instantiator_type_arguments);
}

◆ DoArgumentTypesMatch() [2/3]

ObjectPtr dart::Function::DoArgumentTypesMatch	(	const Array &	args,
		const ArgumentsDescriptor &	arg_names,
		const TypeArguments &	instantiator_type_args
	)		const

Definition at line 9585 of file object.cc.

                                                            {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Precompiler deleted signature because of missing entry point pragma.
    return EntryPointMemberInvocationError(*this);
  }
#endif
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  auto& receiver = Instance::Handle(zone);
  if (IsClosureFunction() || HasThisParameter()) {
    receiver ^= args.At(args_desc.FirstArgIndex());
  }
 
  const auto& function_type_arguments = TypeArguments::Handle(
      zone, RetrieveFunctionTypeArguments(thread, zone, *this, receiver,
                                          instantiator_type_arguments, args,
                                          args_desc));
  return Function::DoArgumentTypesMatch(
      args, args_desc, instantiator_type_arguments, function_type_arguments);
}

◆ DoArgumentTypesMatch() [3/3]

ObjectPtr dart::Function::DoArgumentTypesMatch	(	const Array &	args,
		const ArgumentsDescriptor &	arg_names,
		const TypeArguments &	instantiator_type_args,
		const TypeArguments &	function_type_args
	)		const

Definition at line 9611 of file object.cc.

                                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Precompiler deleted signature because of missing entry point pragma.
    return EntryPointMemberInvocationError(*this);
  }
#endif
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  // Perform any non-covariant bounds checks on the provided function type
  // arguments to make sure they are appropriate subtypes of the bounds.
  const intptr_t kNumLocalTypeArgs = NumTypeParameters();
  if (kNumLocalTypeArgs > 0) {
    const intptr_t kNumParentTypeArgs = NumParentTypeArguments();
    ASSERT(function_type_arguments.HasCount(kNumParentTypeArgs +
                                            kNumLocalTypeArgs));
    const auto& params = TypeParameters::Handle(zone, type_parameters());
    // No checks are needed if all bounds are dynamic.
    if (!params.AllDynamicBounds()) {
      auto& param = AbstractType::Handle(zone);
      auto& bound = AbstractType::Handle(zone);
      for (intptr_t i = 0; i < kNumLocalTypeArgs; i++) {
        bound = params.BoundAt(i);
        // Only perform non-covariant checks where the bound is not
        // the top type.
        if (params.IsGenericCovariantImplAt(i) ||
            bound.IsTopTypeForSubtyping()) {
          continue;
        }
        param = TypeParameterAt(i);
        if (!AbstractType::InstantiateAndTestSubtype(
                &param, &bound, instantiator_type_arguments,
                function_type_arguments)) {
          const auto& names = Array::Handle(zone, params.names());
          auto& name = String::Handle(zone);
          name ^= names.At(i);
          return Error::RawCast(
              ThrowTypeError(token_pos(), param, bound, name));
        }
      }
    }
  } else {
    ASSERT(function_type_arguments.HasCount(NumParentTypeArguments()));
  }
 
  AbstractType& type = AbstractType::Handle(zone);
  Instance& argument = Instance::Handle(zone);
 
  auto check_argument = [](const Instance& argument, const AbstractType& type,
                           const TypeArguments& instantiator_type_args,
                           const TypeArguments& function_type_args) -> bool {
    // If the argument type is the top type, no need to check.
    if (type.IsTopTypeForSubtyping()) return true;
    if (argument.IsNull()) {
      return Instance::NullIsAssignableTo(type, instantiator_type_args,
                                          function_type_args);
    }
    return argument.IsAssignableTo(type, instantiator_type_args,
                                   function_type_args);
  };
 
  // Check types of the provided arguments against the expected parameter types.
  const intptr_t arg_offset = args_desc.FirstArgIndex();
  // Only check explicit arguments.
  const intptr_t arg_start = arg_offset + NumImplicitParameters();
  const intptr_t end_positional_args = arg_offset + args_desc.PositionalCount();
  for (intptr_t arg_index = arg_start; arg_index < end_positional_args;
       ++arg_index) {
    argument ^= args.At(arg_index);
    // Adjust for type arguments when they're present.
    const intptr_t param_index = arg_index - arg_offset;
    type = ParameterTypeAt(param_index);
    if (!check_argument(argument, type, instantiator_type_arguments,
                        function_type_arguments)) {
      auto& name = String::Handle(zone, ParameterNameAt(param_index));
      if (!type.IsInstantiated()) {
        type =
            type.InstantiateFrom(instantiator_type_arguments,
                                 function_type_arguments, kAllFree, Heap::kNew);
      }
      return ThrowTypeError(token_pos(), argument, type, name);
    }
  }
 
  const intptr_t num_named_arguments = args_desc.NamedCount();
  if (num_named_arguments == 0) {
    return Error::null();
  }
 
  const int num_parameters = NumParameters();
  const int num_fixed_params = num_fixed_parameters();
 
  String& argument_name = String::Handle(zone);
  String& parameter_name = String::Handle(zone);
 
  // Check types of named arguments against expected parameter type.
  for (intptr_t named_index = 0; named_index < num_named_arguments;
       named_index++) {
    argument_name = args_desc.NameAt(named_index);
    ASSERT(argument_name.IsSymbol());
    argument ^= args.At(arg_offset + args_desc.PositionAt(named_index));
 
    // Try to find the named parameter that matches the provided argument.
    // Even when annotated with @required, named parameters are still stored
    // as if they were optional and so come after the fixed parameters.
    // Currently O(n^2) as there's no guarantee from either the CFE or the
    // VM that named parameters and named arguments are sorted in the same way.
    intptr_t param_index = num_fixed_params;
    for (; param_index < num_parameters; param_index++) {
      parameter_name = ParameterNameAt(param_index);
      ASSERT(parameter_name.IsSymbol());
 
      if (!parameter_name.Equals(argument_name)) continue;
 
      type = ParameterTypeAt(param_index);
      if (!check_argument(argument, type, instantiator_type_arguments,
                          function_type_arguments)) {
        auto& name = String::Handle(zone, ParameterNameAt(param_index));
        if (!type.IsInstantiated()) {
          type = type.InstantiateFrom(instantiator_type_arguments,
                                      function_type_arguments, kAllFree,
                                      Heap::kNew);
        }
        return ThrowTypeError(token_pos(), argument, type, name);
      }
      break;
    }
    // Only should fail if AreValidArguments returns a false positive.
    ASSERT(param_index < num_parameters);
  }
  return Error::null();
}

◆ DropUncompiledImplicitClosureFunction()

void dart::Function::DropUncompiledImplicitClosureFunction ( ) const

Definition at line 10665 of file object.cc.

                                                           {
  if (implicit_closure_function() != Function::null()) {
    const Function& func = Function::Handle(implicit_closure_function());
    if (!func.HasCode()) {
      set_implicit_closure_function(Function::Handle());
    }
  }
}

◆ end_token_pos()

TokenPosition dart::Function::end_token_pos ( ) const

inline

Definition at line 3435 of file object.h.

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

◆ EnsureHasCode()

CodePtr dart::Function::EnsureHasCode ( ) const

Definition at line 11396 of file object.cc.

                                      {
  if (HasCode()) return CurrentCode();
  Thread* thread = Thread::Current();
  ASSERT(thread->IsDartMutatorThread());
  DEBUG_ASSERT(thread->TopErrorHandlerIsExitFrame());
  Zone* zone = thread->zone();
  const Object& result =
      Object::Handle(zone, Compiler::CompileFunction(thread, *this));
  if (result.IsError()) {
    if (result.ptr() == Object::out_of_memory_error().ptr()) {
      Exceptions::ThrowOOM();
      UNREACHABLE();
    }
    if (result.IsLanguageError()) {
      Exceptions::ThrowCompileTimeError(LanguageError::Cast(result));
      UNREACHABLE();
    }
    Exceptions::PropagateError(Error::Cast(result));
    UNREACHABLE();
  }
  // Compiling in unoptimized mode should never fail if there are no errors.
  RELEASE_ASSERT(HasCode());
  ASSERT(ForceOptimize() || unoptimized_code() == result.ptr());
  return CurrentCode();
}

◆ EnsureHasCompiledUnoptimizedCode()

void dart::Function::EnsureHasCompiledUnoptimizedCode ( ) const

Definition at line 8026 of file object.cc.

                                                      {
  ASSERT(!ForceOptimize());
  Thread* thread = Thread::Current();
  ASSERT(thread->IsDartMutatorThread());
  // TODO(35224): DEBUG_ASSERT(thread->TopErrorHandlerIsExitFrame());
  Zone* zone = thread->zone();
 
  const Error& error =
      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, *this));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
}

◆ entry_point()

uword dart::Function::entry_point ( ) const

inline

Definition at line 3178 of file object.h.

3178{ return EntryPointOf(ptr()); }

dart::Function::EntryPointOf

static uword EntryPointOf(const FunctionPtr function)

Definition object.h:3179

◆ entry_point_offset()

static intptr_t dart::Function::entry_point_offset ( CodeEntryKind entry_kind = CodeEntryKind::kNormal )

inlinestatic

Definition at line 3183 of file object.h.

                                                       {
    switch (entry_kind) {
      case CodeEntryKind::kNormal:
        return OFFSET_OF(UntaggedFunction, entry_point_);
      case CodeEntryKind::kUnchecked:
        return OFFSET_OF(UntaggedFunction, unchecked_entry_point_);
      default:
        UNREACHABLE();
    }
  }

◆ EntryPointOf()

static uword dart::Function::EntryPointOf ( const FunctionPtr function )

inlinestatic

Definition at line 3179 of file object.h.

                                                        {
    return function->untag()->entry_point_;
  }

◆ extracted_method_closure()

FunctionPtr dart::Function::extracted_method_closure ( ) const

Definition at line 8178 of file object.cc.

                                                     {
  ASSERT(kind() == UntaggedFunction::kMethodExtractor);
  const Object& obj = Object::Handle(untag()->data());
  ASSERT(obj.IsFunction());
  return Function::Cast(obj).ptr();
}

◆ FfiCallbackExceptionalReturn()

InstancePtr dart::Function::FfiCallbackExceptionalReturn ( ) const

Definition at line 8449 of file object.cc.

                                                         {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  return FfiTrampolineData::Cast(obj).callback_exceptional_return();
}

◆ FfiCallbackId()

int32_t dart::Function::FfiCallbackId ( ) const

Definition at line 8390 of file object.cc.

                                      {
  ASSERT(IsFfiCallbackTrampoline());
 
  const auto& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  const auto& trampoline_data = FfiTrampolineData::Cast(obj);
 
  ASSERT(trampoline_data.callback_id() != -1);
 
  return trampoline_data.callback_id();
}

◆ FfiCallbackTarget()

FunctionPtr dart::Function::FfiCallbackTarget ( ) const

Definition at line 8435 of file object.cc.

                                              {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  return FfiTrampolineData::Cast(obj).callback_target();
}

◆ FfiCSignature()

FunctionTypePtr dart::Function::FfiCSignature ( ) const

Definition at line 8322 of file object.cc.

                                              {
  auto* const zone = Thread::Current()->zone();
  if (IsFfiCallbackTrampoline()) {
    const Object& obj = Object::Handle(zone, data());
    ASSERT(!obj.IsNull());
    return FfiTrampolineData::Cast(obj).c_signature();
  }
  auto& pragma_value = Instance::Handle(zone);
  if (is_ffi_native()) {
    pragma_value = GetNativeAnnotation();
  } else if (IsFfiCallClosure()) {
    pragma_value = GetFfiCallClosurePragmaValue();
  } else {
    UNREACHABLE();
  }
  const auto& type_args =
      TypeArguments::Handle(zone, pragma_value.GetTypeArguments());
  ASSERT(type_args.Length() == 1);
  const auto& native_type =
      FunctionType::Cast(AbstractType::ZoneHandle(zone, type_args.TypeAt(0)));
  return native_type.ptr();
}

◆ FfiCSignatureContainsHandles()

bool dart::Function::FfiCSignatureContainsHandles ( ) const

Definition at line 8345 of file object.cc.

                                                  {
  const FunctionType& c_signature = FunctionType::Handle(FfiCSignature());
  return c_signature.ContainsHandles();
}

◆ FfiCSignatureReturnsStruct()

bool dart::Function::FfiCSignatureReturnsStruct ( ) const

Definition at line 8364 of file object.cc.

                                                {
  ASSERT(IsFfiCallbackTrampoline());
  Zone* zone = Thread::Current()->zone();
  const auto& c_signature = FunctionType::Handle(zone, FfiCSignature());
  const auto& type = AbstractType::Handle(zone, c_signature.result_type());
  if (IsFfiTypeClassId(type.type_class_id())) {
    return false;
  }
  const auto& cls = Class::Handle(zone, type.type_class());
  const auto& superClass = Class::Handle(zone, cls.SuperClass());
  const bool is_abi_specific_int =
      String::Handle(zone, superClass.UserVisibleName())
          .Equals(Symbols::AbiSpecificInteger());
  if (is_abi_specific_int) {
    return false;
  }
#ifdef DEBUG
  const bool is_struct = String::Handle(zone, superClass.UserVisibleName())
                             .Equals(Symbols::Struct());
  const bool is_union = String::Handle(zone, superClass.UserVisibleName())
                            .Equals(Symbols::Union());
  ASSERT(is_struct || is_union);
#endif
  return true;
}

◆ FfiIsLeaf()

bool dart::Function::FfiIsLeaf ( ) const

Definition at line 8413 of file object.cc.

                               {
  Zone* zone = Thread::Current()->zone();
  auto& pragma_value = Instance::Handle(zone);
  if (is_ffi_native()) {
    pragma_value = GetNativeAnnotation();
  } else if (IsFfiCallClosure()) {
    pragma_value = GetFfiCallClosurePragmaValue();
  } else {
    UNREACHABLE();
  }
  const auto& pragma_value_class = Class::Handle(zone, pragma_value.clazz());
  const auto& pragma_value_fields =
      Array::Handle(zone, pragma_value_class.fields());
  ASSERT(pragma_value_fields.Length() >= 1);
  const auto& is_leaf_field = Field::Handle(
      zone,
      Field::RawCast(pragma_value_fields.At(pragma_value_fields.Length() - 1)));
  ASSERT(is_leaf_field.name() == Symbols::isLeaf().ptr());
  return Bool::Handle(zone, Bool::RawCast(pragma_value.GetField(is_leaf_field)))
      .value();
}

◆ FindICData()

ICDataPtr dart::Function::FindICData ( intptr_t deopt_id ) const

Definition at line 11338 of file object.cc.

                                                      {
  const Array& array = Array::Handle(ic_data_array());
  ICData& ic_data = ICData::Handle();
  for (intptr_t i = ICDataArrayIndices::kFirstICData; i < array.Length(); i++) {
    ic_data ^= array.At(i);
    if (ic_data.deopt_id() == deopt_id) {
      return ic_data.ptr();
    }
  }
  return ICData::null();
}

◆ ForceOptimize()

bool dart::Function::ForceOptimize ( ) const

Definition at line 9075 of file object.cc.

                                   {
  if (RecognizedKindForceOptimize() || IsFfiCallClosure() ||
      IsFfiCallbackTrampoline() || is_ffi_native() ||
      IsTypedDataViewFactory() || IsUnmodifiableTypedDataViewFactory()) {
    return true;
  }
 
  if (!has_pragma()) return false;
 
  const bool has_vm_pragma = Library::FindPragma(
      Thread::Current(), false, *this, Symbols::vm_force_optimize());
  if (!has_vm_pragma) return false;
 
  // For run_vm_tests and runtime/tests/vm allow marking arbitrary functions as
  // force-optimize via `@pragma('vm:force-optimize')`.
  return InVmTests(*this);
}

◆ ForwardingTarget()

FunctionPtr dart::Function::ForwardingTarget ( ) const

Definition at line 8481 of file object.cc.

                                             {
  ASSERT(kind() == UntaggedFunction::kDynamicInvocationForwarder);
  return Function::RawCast(WeakSerializationReference::Unwrap(data()));
}

◆ GetCoverageArray()

ArrayPtr dart::Function::GetCoverageArray ( ) const

Definition at line 11318 of file object.cc.

                                          {
  const Array& arr = Array::Handle(ic_data_array());
  if (arr.IsNull()) {
    return Array::null();
  }
  return Array::RawCast(arr.At(ICDataArrayIndices::kCoverageData));
}

◆ GetDynamicInvocationForwarder()

FunctionPtr dart::Function::GetDynamicInvocationForwarder	(	const String &	mangled_name,
		bool	allow_add = `true`
	)		const

Definition at line 4298 of file object.cc.

                            {
  ASSERT(IsDynamicInvocationForwarderName(mangled_name));
  auto thread = Thread::Current();
  auto zone = thread->zone();
  const Class& owner = Class::Handle(zone, Owner());
  Function& result = Function::Handle(zone);
 
  // First we'll try to find it without using locks.
  result = owner.GetInvocationDispatcher(
      mangled_name, Array::null_array(),
      UntaggedFunction::kDynamicInvocationForwarder,
      /*create_if_absent=*/false);
  if (!result.IsNull()) return result.ptr();
 
  const bool needs_dyn_forwarder =
      kernel::NeedsDynamicInvocationForwarder(*this);
  if (!needs_dyn_forwarder) {
    return ptr();
  }
 
  if (!allow_add) {
    return Function::null();
  }
 
  // 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 mean time.
  result = owner.GetInvocationDispatcher(
      mangled_name, Array::null_array(),
      UntaggedFunction::kDynamicInvocationForwarder,
      /*create_if_absent=*/false);
  if (!result.IsNull()) return result.ptr();
 
  // Otherwise create it & add it.
  result = CreateDynamicInvocationForwarder(mangled_name);
  owner.AddInvocationDispatcher(mangled_name, Array::null_array(), result);
  return result.ptr();
}

◆ GetFfiCallbackKind()

FfiCallbackKind dart::Function::GetFfiCallbackKind ( ) const

Definition at line 8463 of file object.cc.

                                                   {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  return FfiTrampolineData::Cast(obj).ffi_function_kind();
}

◆ GetFfiCallClosurePragmaValue()

InstancePtr dart::Function::GetFfiCallClosurePragmaValue ( ) const

Definition at line 9132 of file object.cc.

                                                         {
  ASSERT(IsFfiCallClosure());
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  auto& pragma_value = Object::Handle(zone);
  Library::FindPragma(thread, /*only_core=*/false, *this,
                      Symbols::vm_ffi_call_closure(),
                      /*multiple=*/false, &pragma_value);
  ASSERT(!pragma_value.IsNull());
  return Instance::Cast(pragma_value).ptr();
}

◆ GetMethodExtractor()

FunctionPtr dart::Function::GetMethodExtractor ( const String & getter_name ) const

Definition at line 4063 of file object.cc.

                                                                        {
  ASSERT(Field::IsGetterName(getter_name));
  const Function& closure_function =
      Function::Handle(ImplicitClosureFunction());
  const Class& owner = Class::Handle(closure_function.Owner());
  Thread* thread = Thread::Current();
  if (owner.EnsureIsFinalized(thread) != Error::null()) {
    return Function::null();
  }
  IsolateGroup* group = thread->isolate_group();
  Function& result = Function::Handle(
      Resolver::ResolveDynamicFunction(thread->zone(), owner, getter_name));
  if (result.IsNull()) {
    SafepointWriteRwLocker ml(thread, group->program_lock());
    result = owner.LookupDynamicFunctionUnsafe(getter_name);
    if (result.IsNull()) {
      result = CreateMethodExtractor(getter_name);
    }
  }
  ASSERT(result.kind() == UntaggedFunction::kMethodExtractor);
  return result.ptr();
}

◆ GetNativeAnnotation()

InstancePtr dart::Function::GetNativeAnnotation ( ) const

Definition at line 8578 of file object.cc.

                                                {
  ASSERT(is_ffi_native());
  Zone* zone = Thread::Current()->zone();
  auto& pragma_value = Object::Handle(zone);
  Library::FindPragma(dart::Thread::Current(), /*only_core=*/false,
                      Object::Handle(zone, ptr()),
                      String::Handle(zone, Symbols::vm_ffi_native().ptr()),
                      /*multiple=*/false, &pragma_value);
  auto const& native_instance = Instance::Cast(pragma_value);
  ASSERT(!native_instance.IsNull());
#if defined(DEBUG)
  const auto& native_class = Class::Handle(zone, native_instance.clazz());
  ASSERT(String::Handle(zone, native_class.UserVisibleName())
             .Equals(Symbols::FfiNative()));
#endif
  return native_instance.ptr();
}

◆ GetOutermostFunction()

FunctionPtr dart::Function::GetOutermostFunction ( ) const

Definition at line 8265 of file object.cc.

                                                 {
  FunctionPtr parent = parent_function();
  if (parent == Object::null()) {
    return ptr();
  }
  Function& function = Function::Handle();
  do {
    function = parent;
    parent = function.parent_function();
  } while (parent != Object::null());
  return function.ptr();
}

◆ GetSource()

StringPtr dart::Function::GetSource ( ) const

Definition at line 11177 of file object.cc.

                                    {
  if (IsImplicitConstructor() || is_synthetic()) {
    // We may need to handle more cases when the restrictions on mixins are
    // relaxed. In particular we might start associating some source with the
    // forwarding constructors when it becomes possible to specify a particular
    // constructor from the mixin to use.
    return String::null();
  }
  Zone* zone = Thread::Current()->zone();
  const Script& func_script = Script::Handle(zone, script());
 
  intptr_t from_line, from_col;
  if (!func_script.GetTokenLocation(token_pos(), &from_line, &from_col)) {
    return String::null();
  }
  intptr_t to_line, to_col;
  if (!func_script.GetTokenLocation(end_token_pos(), &to_line, &to_col)) {
    return String::null();
  }
  intptr_t to_length = func_script.GetTokenLength(end_token_pos());
  if (to_length < 0) {
    return String::null();
  }
 
  if (to_length == 1) {
    // Handle special cases for end tokens of closures (where we exclude the
    // last token):
    // (1) "foo(() => null, bar);": End token is `,', but we don't print it.
    // (2) "foo(() => null);": End token is ')`, but we don't print it.
    // (3) "var foo = () => null;": End token is `;', but in this case the
    // token semicolon belongs to the assignment so we skip it.
    const String& src = String::Handle(func_script.Source());
    if (src.IsNull() || src.Length() == 0) {
      return Symbols::OptimizedOut().ptr();
    }
    uint16_t end_char = src.CharAt(end_token_pos().Pos());
    if ((end_char == ',') ||  // Case 1.
        (end_char == ')') ||  // Case 2.
        (end_char == ';' && String::Handle(zone, name())
                                .Equals("<anonymous closure>"))) {  // Case 3.
      to_length = 0;
    }
  }
 
  return func_script.GetSnippet(from_line, from_col, to_line,
                                to_col + to_length);
}

◆ has_unboxed_double_return()

bool dart::Function::has_unboxed_double_return ( ) const

inline

Definition at line 3799 of file object.h.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
    return untag()->unboxed_parameters_info_.IsUnboxedDouble(0);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ has_unboxed_integer_return()

bool dart::Function::has_unboxed_integer_return ( ) const

inline

Definition at line 3791 of file object.h.

                                          {
#if !defined(DART_PRECOMPILED_RUNTIME)
    return untag()->unboxed_parameters_info_.IsUnboxedInteger(0);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ has_unboxed_record_return()

bool dart::Function::has_unboxed_record_return ( ) const

inline

Definition at line 3807 of file object.h.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
    return untag()->unboxed_parameters_info_.IsUnboxedRecord(0);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ has_unboxed_return()

bool dart::Function::has_unboxed_return ( ) const

inline

Definition at line 3783 of file object.h.

                                  {
#if !defined(DART_PRECOMPILED_RUNTIME)
    return untag()->unboxed_parameters_info_.IsUnboxed(0);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ HasAwaiterLink()

bool dart::Function::HasAwaiterLink ( ) const

inline

Definition at line 3219 of file object.h.

                              {
    return IsClosureFunction() &&
           (awaiter_link().depth != UntaggedClosureData::kNoAwaiterLinkDepth);
  }

◆ HasBreakpoint()

bool dart::Function::HasBreakpoint ( ) const

Definition at line 7948 of file object.cc.

                                   {
#if defined(PRODUCT)
  return false;
#else
  auto thread = Thread::Current();
  return thread->isolate_group()->debugger()->HasBreakpoint(thread, *this);
#endif
}

◆ HasCode() [1/2]

bool dart::Function::HasCode ( ) const

Definition at line 7994 of file object.cc.

                             {
  NoSafepointScope no_safepoint;
  ASSERT(untag()->code() != Code::null());
  return untag()->code() != StubCode::LazyCompile().ptr();
}

◆ HasCode() [2/2]

bool dart::Function::HasCode ( FunctionPtr function )

static

Definition at line 8000 of file object.cc.

                                           {
  NoSafepointScope no_safepoint;
  ASSERT(function->untag()->code() != Code::null());
  return function->untag()->code() != StubCode::LazyCompile().ptr();
}

◆ HasDynamicCallers()

bool dart::Function::HasDynamicCallers ( Zone * zone ) const

Definition at line 11460 of file object.cc.

                                                 {
#if !defined(DART_PRECOMPILED_RUNTIME)
  // Issue(dartbug.com/42719):
  // Right now the metadata of _Closure.call says there are no dynamic callers -
  // even though there can be. To be conservative we return true.
  if ((name() == Symbols::GetCall().ptr() || name() == Symbols::call().ptr()) &&
      Class::IsClosureClass(Owner())) {
    return true;
  }
 
  // Use the results of TFA to determine whether this function is ever
  // called dynamically, i.e. using switchable calls.
  kernel::ProcedureAttributesMetadata metadata;
  metadata = kernel::ProcedureAttributesOf(*this, zone);
  if (IsGetterFunction() || IsImplicitGetterFunction() || IsMethodExtractor()) {
    // Dynamic method call through field/getter involves dynamic call of
    // the field/getter.
    return metadata.getter_called_dynamically ||
           metadata.method_or_setter_called_dynamically;
  } else {
    return metadata.method_or_setter_called_dynamically;
  }
#else
  UNREACHABLE();
  return true;
#endif
}

◆ HasGenericParent()

bool dart::Function::HasGenericParent ( ) const

inline

Definition at line 3123 of file object.h.

3123{ return NumParentTypeArguments() > 0; }

◆ Hash()

uword dart::Function::Hash ( ) const

virtual

Definition at line 7937 of file object.cc.

                           {
  uword hash = String::HashRawSymbol(name());
  if (IsClosureFunction()) {
    hash = hash ^ token_pos().Hash();
  }
  if (Owner()->IsClass()) {
    hash = hash ^ Class::Hash(Class::RawCast(Owner()));
  }
  return hash;
}

◆ HasImplicitClosureFunction()

bool dart::Function::HasImplicitClosureFunction ( ) const

inline

Definition at line 3306 of file object.h.

                                          {
    return implicit_closure_function() != null();
  }

◆ HasInstantiatedSignature()

bool dart::Function::HasInstantiatedSignature	(	Genericity	genericity = `kAny`,
		intptr_t	num_free_fun_type_params = `kAllFree`
	)		const

Definition at line 10843 of file object.cc.

                                             {
  return FunctionType::Handle(signature())
      .IsInstantiated(genericity, num_free_fun_type_params);
}

◆ HasOptimizedCode()

bool dart::Function::HasOptimizedCode ( ) const

Definition at line 11032 of file object.cc.

                                      {
  return HasCode() && Code::Handle(CurrentCode()).is_optimized();
}

◆ HasOptionalNamedParameters()

bool dart::Function::HasOptionalNamedParameters ( ) const

Definition at line 8920 of file object.cc.

                                                {
  return FunctionType::HasOptionalNamedParameters(signature());
}

◆ HasOptionalParameters()

bool dart::Function::HasOptionalParameters ( ) const

Definition at line 8917 of file object.cc.

                                           {
  return FunctionType::HasOptionalParameters(signature());
}

◆ HasOptionalPositionalParameters()

bool dart::Function::HasOptionalPositionalParameters ( ) const

Definition at line 8923 of file object.cc.

                                                     {
  return FunctionType::HasOptionalPositionalParameters(signature());
}

◆ HasParent()

bool dart::Function::HasParent ( ) const

inline

Definition at line 3910 of file object.h.

3910{ return parent_function() != Function::null(); }

◆ HasRequiredNamedParameters()

bool dart::Function::HasRequiredNamedParameters ( ) const

Definition at line 8789 of file object.cc.

                                                {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Signatures for functions with required named parameters are not dropped.
    return false;
  }
#endif
  return FunctionType::Handle(signature()).HasRequiredNamedParameters();
}

◆ HasSavedArgumentsDescriptor()

bool dart::Function::HasSavedArgumentsDescriptor ( ) const

inline

Definition at line 3253 of file object.h.

                                           {
    return IsInvokeFieldDispatcher() || IsNoSuchMethodDispatcher();
  }

◆ HasThisParameter()

bool dart::Function::HasThisParameter ( ) const

inline

Definition at line 3349 of file object.h.

                                {
    return IsDynamicFunction(/*allow_abstract=*/true) ||
           IsGenerativeConstructor() || (IsFieldInitializer() && !is_static());
  }

◆ HasUnboxedParameters()

bool dart::Function::HasUnboxedParameters ( ) const

inline

Definition at line 3816 of file object.h.

                                    {
    return untag()->unboxed_parameters_info_.HasUnboxedParameters();
  }

◆ HasUnboxedReturnValue()

bool dart::Function::HasUnboxedReturnValue ( ) const

inline

Definition at line 3819 of file object.h.

3819{ return has_unboxed_return(); }

dart::Function::has_unboxed_return

bool has_unboxed_return() const

Definition object.h:3783

◆ ic_data_array()

ArrayPtr dart::Function::ic_data_array ( ) const

Definition at line 11330 of file object.cc.

                                       {
  return untag()->ic_data_array<std::memory_order_acquire>();
}

◆ ImplicitClosureFunction()

FunctionPtr dart::Function::ImplicitClosureFunction ( ) const

Definition at line 10443 of file object.cc.

                                                    {
  // Return the existing implicit closure function if any.
  if (implicit_closure_function() != Function::null()) {
    return implicit_closure_function();
  }
 
#if defined(DART_PRECOMPILED_RUNTIME)
  // In AOT mode all implicit closures are pre-created.
  FATAL("Cannot create implicit closure in AOT!");
  return Function::null();
#else
  ASSERT(!IsClosureFunction());
  Thread* thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  if (implicit_closure_function() != Function::null()) {
    return implicit_closure_function();
  }
 
  // Create closure function.
  Zone* zone = thread->zone();
  const String& closure_name = String::Handle(zone, name());
  const Function& closure_function = Function::Handle(
      zone, NewImplicitClosureFunction(closure_name, *this, token_pos()));
 
  // Set closure function's context scope.
  if (is_static() || IsConstructor()) {
    closure_function.set_context_scope(Object::empty_context_scope());
  } else {
    const ContextScope& context_scope = ContextScope::Handle(
        zone, LocalScope::CreateImplicitClosureScope(*this));
    closure_function.set_context_scope(context_scope);
  }
 
  FunctionType& closure_signature =
      FunctionType::Handle(zone, closure_function.signature());
 
  const auto& cls = Class::Handle(zone, Owner());
 
  if (!is_static() && !IsConstructor() &&
      StackTraceUtils::IsPossibleAwaiterLink(cls)) {
    closure_function.set_awaiter_link({0, 0});
  }
 
  const intptr_t num_type_params =
      IsConstructor() ? cls.NumTypeParameters() : NumTypeParameters();
 
  TypeArguments& instantiator_type_arguments = TypeArguments::Handle(zone);
  TypeArguments& function_type_arguments = TypeArguments::Handle(zone);
 
  FunctionTypeMapping* function_type_mapping = nullptr;
  FunctionTypeMapping scope(zone, &function_type_mapping,
                            FunctionType::Handle(zone, signature()),
                            closure_signature);
 
  auto transform_type = [&](AbstractType& type) {
    if (num_type_params > 0) {
      if (IsConstructor()) {
        type = type.UpdateFunctionTypes(num_type_params, kAllFree, Heap::kOld,
                                        nullptr);
        if (!type.IsInstantiated(kCurrentClass)) {
          type = type.InstantiateFrom(
              instantiator_type_arguments, function_type_arguments,
              kNoneFree /* avoid truncating parent type args */, Heap::kOld);
        }
      } else {
        type = type.UpdateFunctionTypes(0, kNoneFree, Heap::kOld,
                                        function_type_mapping);
      }
    }
  };
 
  auto transform_type_args = [&](TypeArguments& type_args) {
    ASSERT(num_type_params > 0);
    if (!type_args.IsNull()) {
      if (IsConstructor()) {
        type_args = type_args.UpdateFunctionTypes(num_type_params, kAllFree,
                                                  Heap::kOld, nullptr);
        if (!type_args.IsInstantiated(kCurrentClass)) {
          type_args = type_args.InstantiateFrom(
              instantiator_type_arguments, function_type_arguments,
              kNoneFree /* avoid truncating parent type args */, Heap::kOld);
        }
      } else {
        type_args = type_args.UpdateFunctionTypes(0, kNoneFree, Heap::kOld,
                                                  function_type_mapping);
      }
    }
  };
 
  // Set closure function's type parameters.
  if (num_type_params > 0) {
    const TypeParameters& old_type_params = TypeParameters::Handle(
        zone, IsConstructor() ? cls.type_parameters() : type_parameters());
    const TypeParameters& new_type_params =
        TypeParameters::Handle(zone, TypeParameters::New());
    // No need to set names that are ignored in a signature, however, the
    // length of the names array defines the number of type parameters.
    new_type_params.set_names(Array::Handle(zone, old_type_params.names()));
    new_type_params.set_flags(Array::Handle(zone, old_type_params.flags()));
 
    closure_signature.SetTypeParameters(new_type_params);
    ASSERT(closure_signature.NumTypeParameters() == num_type_params);
 
    TypeArguments& type_args = TypeArguments::Handle(zone);
    type_args = TypeArguments::New(num_type_params);
    TypeParameter& type_param = TypeParameter::Handle(zone);
    for (intptr_t i = 0; i < num_type_params; i++) {
      type_param = closure_signature.TypeParameterAt(i);
      type_args.SetTypeAt(i, type_param);
    }
 
    if (IsConstructor()) {
      instantiator_type_arguments =
          type_args.ToInstantiatorTypeArguments(thread, cls);
    } else {
      ASSERT(NumTypeArguments() == type_args.Length());
      function_type_arguments = type_args.ptr();
    }
 
    type_args = old_type_params.bounds();
    transform_type_args(type_args);
    new_type_params.set_bounds(type_args);
 
    type_args = old_type_params.defaults();
    transform_type_args(type_args);
    new_type_params.set_defaults(type_args);
  }
 
  // Set closure function's result type.
  AbstractType& result_type = AbstractType::Handle(zone);
  if (IsConstructor()) {
    result_type = cls.DeclarationType();
  } else {
    result_type = this->result_type();
  }
  transform_type(result_type);
  closure_signature.set_result_type(result_type);
 
  // Set closure function's end token to this end token.
  closure_function.set_end_token_pos(end_token_pos());
 
  // The closurized method stub just calls into the original method and should
  // therefore be skipped by the debugger and in stack traces.
  closure_function.set_is_debuggable(false);
  closure_function.set_is_visible(false);
 
  // Set closure function's formal parameters to this formal parameters,
  // removing the receiver if this is an instance method and adding the closure
  // object as first parameter.
  const int kClosure = 1;
  const int num_implicit_params = NumImplicitParameters();
  const int num_fixed_params =
      kClosure - num_implicit_params + num_fixed_parameters();
  const int num_opt_params = NumOptionalParameters();
  const bool has_opt_pos_params = HasOptionalPositionalParameters();
  const int num_params = num_fixed_params + num_opt_params;
  const int num_pos_params = has_opt_pos_params ? num_params : num_fixed_params;
  closure_signature.set_num_fixed_parameters(num_fixed_params);
  closure_signature.SetNumOptionalParameters(num_opt_params,
                                             has_opt_pos_params);
  closure_signature.set_parameter_types(
      Array::Handle(zone, Array::New(num_params, Heap::kOld)));
  closure_function.CreateNameArray();
  closure_signature.CreateNameArrayIncludingFlags();
  AbstractType& param_type = AbstractType::Handle(zone);
  String& param_name = String::Handle(zone);
  // Add implicit closure object parameter.
  param_type = Type::DynamicType();
  closure_signature.SetParameterTypeAt(0, param_type);
  closure_function.SetParameterNameAt(0, Symbols::ClosureParameter());
  for (int i = kClosure; i < num_pos_params; i++) {
    param_type = ParameterTypeAt(num_implicit_params - kClosure + i);
    transform_type(param_type);
    closure_signature.SetParameterTypeAt(i, param_type);
    param_name = ParameterNameAt(num_implicit_params - kClosure + i);
    // Set the name in the function for positional parameters.
    closure_function.SetParameterNameAt(i, param_name);
  }
  for (int i = num_pos_params; i < num_params; i++) {
    param_type = ParameterTypeAt(num_implicit_params - kClosure + i);
    transform_type(param_type);
    closure_signature.SetParameterTypeAt(i, param_type);
    param_name = ParameterNameAt(num_implicit_params - kClosure + i);
    // Set the name in the signature for named parameters.
    closure_signature.SetParameterNameAt(i, param_name);
    if (IsRequiredAt(num_implicit_params - kClosure + i)) {
      closure_signature.SetIsRequiredAt(i);
    }
  }
  closure_signature.FinalizeNameArray();
  closure_function.InheritKernelOffsetFrom(*this);
 
  if (!is_static() && !IsConstructor()) {
    // Change covariant parameter types to Object?.
    BitVector is_covariant(zone, NumParameters());
    BitVector is_generic_covariant_impl(zone, NumParameters());
    kernel::ReadParameterCovariance(*this, &is_covariant,
                                    &is_generic_covariant_impl);
 
    ObjectStore* object_store = IsolateGroup::Current()->object_store();
    const auto& object_type =
        Type::Handle(zone, object_store->nullable_object_type());
    ASSERT(object_type.IsCanonical());
    for (intptr_t i = kClosure; i < num_params; ++i) {
      const intptr_t original_param_index = num_implicit_params - kClosure + i;
      if (is_covariant.Contains(original_param_index) ||
          is_generic_covariant_impl.Contains(original_param_index)) {
        closure_signature.SetParameterTypeAt(i, object_type);
      }
    }
  }
  ASSERT(!closure_signature.IsFinalized());
  closure_signature ^= ClassFinalizer::FinalizeType(closure_signature);
  closure_function.SetSignature(closure_signature);
  set_implicit_closure_function(closure_function);
  ASSERT(closure_function.IsImplicitClosureFunction());
  ASSERT(HasImplicitClosureFunction());
  return closure_function.ptr();
#endif  // defined(DART_PRECOMPILED_RUNTIME)
}

◆ ImplicitClosureTarget()

FunctionPtr dart::Function::ImplicitClosureTarget ( Zone * zone ) const

Definition at line 10792 of file object.cc.

                                                            {
  const auto& parent = Function::Handle(zone, parent_function());
  const auto& func_name = String::Handle(zone, parent.name());
  const auto& owner = Class::Handle(zone, parent.Owner());
  Thread* thread = Thread::Current();
  const auto& error = owner.EnsureIsFinalized(thread);
  ASSERT(error == Error::null());
  auto& target =
      Function::Handle(zone, Resolver::ResolveFunction(zone, owner, func_name));
 
  if (!target.IsNull() && (target.ptr() != parent.ptr())) {
    DEBUG_ASSERT(IsolateGroup::Current()->HasAttemptedReload());
    if ((target.is_static() != parent.is_static()) ||
        (target.kind() != parent.kind())) {
      target = Function::null();
    }
  }
 
  return target.ptr();
}

◆ ImplicitInstanceClosure()

ClosurePtr dart::Function::ImplicitInstanceClosure ( const Instance & receiver ) const

Definition at line 10780 of file object.cc.

                                                                           {
  ASSERT(IsImplicitClosureFunction());
  Zone* zone = Thread::Current()->zone();
  TypeArguments& instantiator_type_arguments = TypeArguments::Handle(zone);
  if (!HasInstantiatedSignature(kCurrentClass)) {
    instantiator_type_arguments = receiver.GetTypeArguments();
  }
  ASSERT(!HasGenericParent());  // No generic parent function.
  return Closure::New(instantiator_type_arguments,
                      Object::null_type_arguments(), *this, receiver);
}

◆ ImplicitStaticClosure()

ClosurePtr dart::Function::ImplicitStaticClosure ( ) const

Definition at line 10758 of file object.cc.

                                                 {
  ASSERT(IsImplicitStaticClosureFunction());
  if (implicit_static_closure() != Closure::null()) {
    return implicit_static_closure();
  }
 
  auto thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  if (implicit_static_closure() != Closure::null()) {
    return implicit_static_closure();
  }
 
  Zone* zone = thread->zone();
  const auto& closure =
      Closure::Handle(zone, Closure::New(Object::null_type_arguments(),
                                         Object::null_type_arguments(), *this,
                                         Object::null_object(), Heap::kOld));
  set_implicit_static_closure(closure);
  return implicit_static_closure();
}

◆ InheritKernelOffsetFrom() [1/2]

void dart::Function::InheritKernelOffsetFrom ( const Field & src ) const

Definition at line 10917 of file object.cc.

                                                             {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  set_kernel_offset(src.kernel_offset());
#endif
}

◆ InheritKernelOffsetFrom() [2/2]

void dart::Function::InheritKernelOffsetFrom ( const Function & src ) const

Definition at line 10909 of file object.cc.

                                                                {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  StoreNonPointer(&untag()->kernel_offset_, src.untag()->kernel_offset_);
#endif
}

◆ InstallOptimizedCode()

void dart::Function::InstallOptimizedCode ( const Code & code ) const

Definition at line 7957 of file object.cc.

                                                          {
  ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
  // We may not have previous code if FLAG_precompile is set.
  // Hot-reload may have already disabled the current code.
  if (HasCode() && !Code::Handle(CurrentCode()).IsDisabled()) {
    Code::Handle(CurrentCode()).DisableDartCode();
  }
  AttachCode(code);
}

◆ InstanceSize()

static intptr_t dart::Function::InstanceSize ( )

inlinestatic

Definition at line 3965 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedFunction));
  }

◆ InternalSignature()

StringPtr dart::Function::InternalSignature ( ) const

Definition at line 10674 of file object.cc.

                                            {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    return String::null();
  }
#endif
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  const FunctionType& sig = FunctionType::Handle(signature());
  sig.Print(kInternalName, &printer);
  return Symbols::New(thread, printer.buffer());
}

◆ is_ffi_native()

bool dart::Function::is_ffi_native ( ) const

Definition at line 8600 of file object.cc.

                                   {
  return is_native() && is_external();
}

◆ is_old_native()

bool dart::Function::is_old_native ( ) const

Definition at line 8596 of file object.cc.

                                   {
  return is_native() && !is_external();
}

◆ is_optimizable()

bool dart::Function::is_optimizable ( ) const

inline

Definition at line 4178 of file object.h.

                              {
#if defined(DART_PRECOMPILED_RUNTIME)
    return false;
#else
    return untag()->packed_fields_.Read<UntaggedFunction::PackedOptimizable>();
#endif
  }

◆ is_sticky_specialization()

bool dart::Function::is_sticky_specialization ( ) const

Definition at line 8544 of file object.cc.

                                              {
  ASSERT(kind() == UntaggedFunction::kIrregexpFunction);
  const Array& pair = Array::Cast(Object::Handle(data()));
  return StickySpecialization::decode(Smi::Value(Smi::RawCast(pair.At(1))));
}

◆ is_unboxed_double_parameter_at()

bool dart::Function::is_unboxed_double_parameter_at ( intptr_t index ) const

inline

Definition at line 3773 of file object.h.

                                                            {
#if !defined(DART_PRECOMPILED_RUNTIME)
    ASSERT(index >= 0);
    index++;  // position 0 is reserved for the return value
    return untag()->unboxed_parameters_info_.IsUnboxedDouble(index);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ is_unboxed_integer_parameter_at()

bool dart::Function::is_unboxed_integer_parameter_at ( intptr_t index ) const

inline

Definition at line 3763 of file object.h.

                                                             {
#if !defined(DART_PRECOMPILED_RUNTIME)
    ASSERT(index >= 0);
    index++;  // position 0 is reserved for the return value
    return untag()->unboxed_parameters_info_.IsUnboxedInteger(index);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ is_unboxed_parameter_at()

bool dart::Function::is_unboxed_parameter_at ( intptr_t index ) const

inline

Definition at line 3753 of file object.h.

                                                     {
#if !defined(DART_PRECOMPILED_RUNTIME)
    ASSERT(index >= 0);
    index++;  // position 0 is reserved for the return value
    return untag()->unboxed_parameters_info_.IsUnboxed(index);
#else
    return false;
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ is_visible()

static bool dart::Function::is_visible ( FunctionPtr f )

inlinestatic

Definition at line 4163 of file object.h.

                                        {
    return f.untag()->kind_tag_.Read<VisibleBit>();
  }

◆ IsAsyncFunction()

bool dart::Function::IsAsyncFunction ( ) const

inline

Definition at line 3942 of file object.h.

                               {
    return modifier() == UntaggedFunction::kAsync;
  }

◆ IsAsyncGenerator()

bool dart::Function::IsAsyncGenerator ( ) const

inline

Definition at line 3952 of file object.h.

                                {
    return modifier() == UntaggedFunction::kAsyncGen;
  }

◆ IsCachableIdempotent()

bool dart::Function::IsCachableIdempotent ( ) const

Definition at line 9113 of file object.cc.

                                          {
  if (!has_pragma()) return false;
 
  const bool has_vm_pragma =
      Library::FindPragma(Thread::Current(), /*only_core=*/false, *this,
                          Symbols::vm_cachable_idempotent());
  if (!has_vm_pragma) return false;
 
  // For run_vm_tests and runtime/tests/vm allow marking arbitrary functions.
  return InVmTests(*this);
}

◆ IsClosureFunction()

bool dart::Function::IsClosureFunction ( ) const

inline

Definition at line 3871 of file object.h.

                                 {
    UntaggedFunction::Kind k = kind();
    return (k == UntaggedFunction::kClosureFunction) ||
           (k == UntaggedFunction::kImplicitClosureFunction);
  }

◆ IsConstructor()

bool dart::Function::IsConstructor ( ) const

inline

Definition at line 3340 of file object.h.

                             {
    return kind() == UntaggedFunction::kConstructor;
  }

◆ IsDispatcherOrImplicitAccessor()

bool dart::Function::IsDispatcherOrImplicitAccessor ( ) const

inline

Definition at line 3822 of file object.h.

                                              {
    switch (kind()) {
      case UntaggedFunction::kImplicitGetter:
      case UntaggedFunction::kImplicitSetter:
      case UntaggedFunction::kImplicitStaticGetter:
      case UntaggedFunction::kNoSuchMethodDispatcher:
      case UntaggedFunction::kInvokeFieldDispatcher:
      case UntaggedFunction::kDynamicInvocationForwarder:
        return true;
      default:
        return false;
    }
  }

◆ IsDynamicClosureCallDispatcher() [1/2]

bool dart::Function::IsDynamicClosureCallDispatcher ( ) const

inline

Definition at line 3288 of file object.h.

                                              {
    if (!IsDynamicInvokeFieldDispatcher()) return false;
    return IsDynamicClosureCallDispatcher(Thread::Current());
  }

◆ IsDynamicClosureCallDispatcher() [2/2]

bool dart::Function::IsDynamicClosureCallDispatcher ( Thread * thread ) const

Definition at line 10434 of file object.cc.

                                                                  {
  if (!IsInvokeFieldDispatcher()) return false;
  if (thread->isolate_group()->object_store()->closure_class() != Owner()) {
    return false;
  }
  const auto& handle = String::Handle(thread->zone(), name());
  return handle.Equals(Symbols::DynamicCall());
}

◆ IsDynamicFunction()

bool dart::Function::IsDynamicFunction ( bool allow_abstract = false ) const

inline

Definition at line 3354 of file object.h.

                                                            {
    if (is_static() || (!allow_abstract && is_abstract())) {
      return false;
    }
    switch (kind()) {
      case UntaggedFunction::kRegularFunction:
      case UntaggedFunction::kGetterFunction:
      case UntaggedFunction::kSetterFunction:
      case UntaggedFunction::kImplicitGetter:
      case UntaggedFunction::kImplicitSetter:
      case UntaggedFunction::kMethodExtractor:
      case UntaggedFunction::kNoSuchMethodDispatcher:
      case UntaggedFunction::kInvokeFieldDispatcher:
      case UntaggedFunction::kDynamicInvocationForwarder:
      case UntaggedFunction::kRecordFieldGetter:
        return true;
      case UntaggedFunction::kClosureFunction:
      case UntaggedFunction::kImplicitClosureFunction:
      case UntaggedFunction::kConstructor:
      case UntaggedFunction::kImplicitStaticGetter:
      case UntaggedFunction::kFieldInitializer:
      case UntaggedFunction::kIrregexpFunction:
        return false;
      default:
        UNREACHABLE();
        return false;
    }
  }

◆ IsDynamicInvocationForwarder()

bool dart::Function::IsDynamicInvocationForwarder ( ) const

inline

Definition at line 3294 of file object.h.

                                            {
    return kind() == UntaggedFunction::kDynamicInvocationForwarder;
  }

◆ IsDynamicInvocationForwarderName() [1/2]

bool dart::Function::IsDynamicInvocationForwarderName ( const String & name )

static

Definition at line 4240 of file object.cc.

                                                                  {
  return IsDynamicInvocationForwarderName(name.ptr());
}

◆ IsDynamicInvocationForwarderName() [2/2]

bool dart::Function::IsDynamicInvocationForwarderName ( StringPtr name )

static

Definition at line 4244 of file object.cc.

                                                              {
  return String::StartsWith(name, Symbols::DynamicPrefix().ptr());
}

◆ IsDynamicInvokeFieldDispatcher()

bool dart::Function::IsDynamicInvokeFieldDispatcher ( ) const

inline

Definition at line 3280 of file object.h.

                                              {
    return IsInvokeFieldDispatcher() &&
           IsDynamicInvocationForwarderName(name());
  }

◆ IsFactory()

bool dart::Function::IsFactory ( ) const

inline

Definition at line 3347 of file object.h.

3347{ return IsConstructor() && is_static(); }

◆ IsFfiCallbackTrampoline() [1/2]

bool dart::Function::IsFfiCallbackTrampoline ( ) const

inline

Definition at line 3918 of file object.h.

                                       {
    return kind() == UntaggedFunction::kFfiTrampoline;
  }

◆ IsFfiCallbackTrampoline() [2/2]

static bool dart::Function::IsFfiCallbackTrampoline ( FunctionPtr function )

inlinestatic

Definition at line 3921 of file object.h.

                                                            {
    NoSafepointScope no_safepoint;
    return function->untag()->kind_tag_.Read<KindBits>() ==
           UntaggedFunction::kFfiTrampoline;
  }

◆ IsFfiCallClosure()

bool dart::Function::IsFfiCallClosure ( ) const

Definition at line 9125 of file object.cc.

                                      {
  if (!IsNonImplicitClosureFunction()) return false;
  if (!has_pragma()) return false;
  return Library::FindPragma(Thread::Current(), /*only_core=*/false, *this,
                             Symbols::vm_ffi_call_closure());
}

◆ IsFieldInitializer()

bool dart::Function::IsFieldInitializer ( ) const

inline

Definition at line 3865 of file object.h.

                                  {
    return kind() == UntaggedFunction::kFieldInitializer;
  }

◆ IsGenerativeConstructor()

bool dart::Function::IsGenerativeConstructor ( ) const

inline

Definition at line 3343 of file object.h.

                                       {
    return IsConstructor() && !is_static();
  }

◆ IsGeneric()

bool dart::Function::IsGeneric ( ) const

Definition at line 8902 of file object.cc.

                               {
  return FunctionType::IsGeneric(signature());
}

◆ IsGetterFunction()

bool dart::Function::IsGetterFunction ( ) const

inline

Definition at line 3837 of file object.h.

                                {
    return kind() == UntaggedFunction::kGetterFunction;
  }

◆ IsIdempotent()

bool dart::Function::IsIdempotent ( ) const

Definition at line 9100 of file object.cc.

                                  {
  if (!has_pragma()) return false;
 
#if defined(TESTING)
  const bool kAllowOnlyForCoreLibFunctions = false;
#else
  const bool kAllowOnlyForCoreLibFunctions = true;
#endif  // defined(TESTING)
 
  return Library::FindPragma(Thread::Current(), kAllowOnlyForCoreLibFunctions,
                             *this, Symbols::vm_idempotent());
}

◆ IsImplicitClosureFunction() [1/2]

bool dart::Function::IsImplicitClosureFunction ( ) const

inline

Definition at line 3883 of file object.h.

                                         {
    return kind() == UntaggedFunction::kImplicitClosureFunction;
  }

◆ IsImplicitClosureFunction() [2/2]

static bool dart::Function::IsImplicitClosureFunction ( FunctionPtr func )

inlinestatic

Definition at line 3886 of file object.h.

                                                          {
    return KindOf(func) == UntaggedFunction::kImplicitClosureFunction;
  }

◆ IsImplicitConstructor()

bool dart::Function::IsImplicitConstructor ( ) const

Definition at line 10276 of file object.cc.

                                           {
  return IsGenerativeConstructor() && (token_pos() == end_token_pos());
}

◆ IsImplicitGetterFunction()

bool dart::Function::IsImplicitGetterFunction ( ) const

inline

Definition at line 3842 of file object.h.

                                        {
    return kind() == UntaggedFunction::kImplicitGetter;
  }

◆ IsImplicitGetterOrSetter()

bool dart::Function::IsImplicitGetterOrSetter ( ) const

inline

Definition at line 3298 of file object.h.

                                        {
    return kind() == UntaggedFunction::kImplicitGetter ||
           kind() == UntaggedFunction::kImplicitSetter ||
           kind() == UntaggedFunction::kImplicitStaticGetter;
  }

◆ IsImplicitInstanceClosureFunction() [1/2]

bool dart::Function::IsImplicitInstanceClosureFunction ( ) const

inline

Definition at line 3904 of file object.h.

                                                 {
    return IsImplicitClosureFunction() && !is_static();
  }

◆ IsImplicitInstanceClosureFunction() [2/2]

bool dart::Function::IsImplicitInstanceClosureFunction ( FunctionPtr func )

static

Definition at line 10288 of file object.cc.

                                                                 {
  NoSafepointScope no_safepoint;
  uint32_t kind_tag = func->untag()->kind_tag_.load(std::memory_order_relaxed);
  return (KindBits::decode(kind_tag) ==
          UntaggedFunction::kImplicitClosureFunction) &&
         !StaticBit::decode(kind_tag);
}

◆ IsImplicitSetterFunction()

bool dart::Function::IsImplicitSetterFunction ( ) const

inline

Definition at line 3858 of file object.h.

                                        {
    return kind() == UntaggedFunction::kImplicitSetter;
  }

◆ IsImplicitStaticClosureFunction() [1/2]

bool dart::Function::IsImplicitStaticClosureFunction ( ) const

inline

Definition at line 3897 of file object.h.

                                               {
    return IsImplicitClosureFunction() && is_static();
  }

◆ IsImplicitStaticClosureFunction() [2/2]

bool dart::Function::IsImplicitStaticClosureFunction ( FunctionPtr func )

static

Definition at line 10280 of file object.cc.

                                                               {
  NoSafepointScope no_safepoint;
  uint32_t kind_tag = func->untag()->kind_tag_.load(std::memory_order_relaxed);
  return (KindBits::decode(kind_tag) ==
          UntaggedFunction::kImplicitClosureFunction) &&
         StaticBit::decode(kind_tag);
}

◆ IsImplicitStaticGetterFunction()

bool dart::Function::IsImplicitStaticGetterFunction ( ) const

inline

Definition at line 3848 of file object.h.

                                              {
    return kind() == UntaggedFunction::kImplicitStaticGetter;
  }

◆ IsInvokeFieldDispatcher()

bool dart::Function::IsInvokeFieldDispatcher ( ) const

inline

Definition at line 3276 of file object.h.

                                       {
    return kind() == UntaggedFunction::kInvokeFieldDispatcher;
  }

◆ IsIrregexpFunction()

bool dart::Function::IsIrregexpFunction ( ) const

inline

Definition at line 3878 of file object.h.

                                  {
    return kind() == UntaggedFunction::kIrregexpFunction;
  }

◆ IsLocalFunction()

bool dart::Function::IsLocalFunction ( ) const

inline

Definition at line 3913 of file object.h.

                               {
    return !IsImplicitClosureFunction() && HasParent();
  }

◆ IsMethodExtractor()

bool dart::Function::IsMethodExtractor ( ) const

inline

Definition at line 3264 of file object.h.

                                 {
    return kind() == UntaggedFunction::kMethodExtractor;
  }

◆ IsNonImplicitClosureFunction()

bool dart::Function::IsNonImplicitClosureFunction ( ) const

inline

Definition at line 3891 of file object.h.

                                            {
    return IsClosureFunction() && !IsImplicitClosureFunction();
  }

◆ IsNoSuchMethodDispatcher()

bool dart::Function::IsNoSuchMethodDispatcher ( ) const

inline

Definition at line 3268 of file object.h.

                                        {
    return kind() == UntaggedFunction::kNoSuchMethodDispatcher;
  }

◆ IsOptimizable()

bool dart::Function::IsOptimizable ( ) const

Definition at line 8988 of file object.cc.

                                   {
  if (FLAG_precompiled_mode) {
    return true;
  }
  if (ForceOptimize()) return true;
  if (is_old_native()) {
    // Native methods don't need to be optimized.
    return false;
  }
  if (is_optimizable() && (script() != Script::null())) {
    // Additional check needed for implicit getters.
    return (unoptimized_code() == Object::null()) ||
           (Code::Handle(unoptimized_code()).Size() <
            FLAG_huge_method_cutoff_in_code_size);
  }
  return false;
}

◆ IsPreferInline()

bool dart::Function::IsPreferInline ( ) const

Definition at line 9093 of file object.cc.

                                    {
  if (!has_pragma()) return false;
 
  return Library::FindPragma(Thread::Current(), /*only_core=*/false, *this,
                             Symbols::vm_prefer_inline());
}

◆ IsPrivate()

bool dart::Function::IsPrivate ( ) const

Definition at line 10895 of file object.cc.

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

◆ IsRecognized()

bool dart::Function::IsRecognized ( ) const

inline

Definition at line 3604 of file object.h.

                            {
    return recognized_kind() != MethodRecognizer::kUnknown;
  }

◆ IsRecordFieldGetter()

bool dart::Function::IsRecordFieldGetter ( ) const

inline

Definition at line 3272 of file object.h.

                                   {
    return kind() == UntaggedFunction::kRecordFieldGetter;
  }

◆ IsRegularFunction()

bool dart::Function::IsRegularFunction ( ) const

inline

Definition at line 3260 of file object.h.

                                 {
    return kind() == UntaggedFunction::kRegularFunction;
  }

◆ IsRequiredAt()

bool dart::Function::IsRequiredAt ( intptr_t index ) const

Definition at line 8799 of file object.cc.

                                                {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Signature is not dropped in aot when any named parameter is required.
    return false;
  }
#endif
  if (!HasOptionalNamedParameters() || index < num_fixed_parameters()) {
    return false;
  }
  const FunctionType& sig = FunctionType::Handle(signature());
  return sig.IsRequiredAt(index);
}

◆ IsSetterFunction()

bool dart::Function::IsSetterFunction ( ) const

inline

Definition at line 3853 of file object.h.

                                {
    return kind() == UntaggedFunction::kSetterFunction;
  }

◆ IsStaticFunction()

bool dart::Function::IsStaticFunction ( ) const

inline

Definition at line 3382 of file object.h.

                                {
    if (!is_static()) {
      return false;
    }
    switch (kind()) {
      case UntaggedFunction::kRegularFunction:
      case UntaggedFunction::kGetterFunction:
      case UntaggedFunction::kSetterFunction:
      case UntaggedFunction::kImplicitGetter:
      case UntaggedFunction::kImplicitSetter:
      case UntaggedFunction::kImplicitStaticGetter:
      case UntaggedFunction::kFieldInitializer:
      case UntaggedFunction::kIrregexpFunction:
        return true;
      case UntaggedFunction::kClosureFunction:
      case UntaggedFunction::kImplicitClosureFunction:
      case UntaggedFunction::kConstructor:
      case UntaggedFunction::kMethodExtractor:
      case UntaggedFunction::kNoSuchMethodDispatcher:
      case UntaggedFunction::kInvokeFieldDispatcher:
      case UntaggedFunction::kDynamicInvocationForwarder:
      case UntaggedFunction::kFfiTrampoline:
      case UntaggedFunction::kRecordFieldGetter:
        return false;
      default:
        UNREACHABLE();
        return false;
    }
  }

◆ IsSuspendableFunction()

bool dart::Function::IsSuspendableFunction ( ) const

inline

Definition at line 3937 of file object.h.

                                     {
    return modifier() != UntaggedFunction::kNoModifier;
  }

◆ IsSyncGenerator()

bool dart::Function::IsSyncGenerator ( ) const

inline

Definition at line 3947 of file object.h.

                               {
    return modifier() == UntaggedFunction::kSyncGen;
  }

◆ IsTypedDataViewFactory()

bool dart::Function::IsTypedDataViewFactory ( ) const

Definition at line 9015 of file object.cc.

                                            {
  switch (recognized_kind()) {
    case MethodRecognizer::kTypedData_ByteDataView_factory:
    case MethodRecognizer::kTypedData_Int8ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint8ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint8ClampedArrayView_factory:
    case MethodRecognizer::kTypedData_Int16ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint16ArrayView_factory:
    case MethodRecognizer::kTypedData_Int32ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint32ArrayView_factory:
    case MethodRecognizer::kTypedData_Int64ArrayView_factory:
    case MethodRecognizer::kTypedData_Uint64ArrayView_factory:
    case MethodRecognizer::kTypedData_Float32ArrayView_factory:
    case MethodRecognizer::kTypedData_Float64ArrayView_factory:
    case MethodRecognizer::kTypedData_Float32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_Int32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_Float64x2ArrayView_factory:
      return true;
    default:
      return false;
  }
}

◆ IsUnmodifiableTypedDataViewFactory()

bool dart::Function::IsUnmodifiableTypedDataViewFactory ( ) const

Definition at line 9038 of file object.cc.

                                                        {
  switch (recognized_kind()) {
    case MethodRecognizer::kTypedData_UnmodifiableByteDataView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt8ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint8ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint8ClampedArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt16ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint16ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableUint64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat32ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat64ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableInt32x4ArrayView_factory:
    case MethodRecognizer::kTypedData_UnmodifiableFloat64x2ArrayView_factory:
      return true;
    default:
      return false;
  }
}

◆ kernel_offset()

intptr_t dart::Function::kernel_offset ( ) const

inline

Definition at line 3530 of file object.h.

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

◆ KernelLibrary()

TypedDataViewPtr dart::Function::KernelLibrary ( ) const

Definition at line 10994 of file object.cc.

                                               {
  const auto& info = KernelProgramInfo::Handle(KernelProgramInfo());
  return info.KernelLibrary(KernelLibraryIndex());
}

◆ KernelLibraryIndex()

intptr_t dart::Function::KernelLibraryIndex ( ) const

Definition at line 11006 of file object.cc.

                                            {
  if (IsNoSuchMethodDispatcher() || IsInvokeFieldDispatcher() ||
      IsFfiCallbackTrampoline()) {
    return -1;
  }
  if (is_eval_function()) {
    const auto& fdata = Array::Handle(Array::RawCast(data()));
    return Smi::Value(static_cast<SmiPtr>(fdata.At(
        static_cast<intptr_t>(EvalFunctionData::kKernelLibraryIndex))));
  }
  if (IsClosureFunction()) {
    const auto& parent = Function::Handle(parent_function());
    ASSERT(!parent.IsNull());
    return parent.KernelLibraryIndex();
  }
 
  const auto& obj = Object::Handle(untag()->owner());
  if (obj.IsClass()) {
    const auto& lib = Library::Handle(Class::Cast(obj).library());
    return lib.kernel_library_index();
  }
  ASSERT(obj.IsPatchClass());
  return PatchClass::Cast(obj).kernel_library_index();
}

◆ KernelLibraryOffset()

intptr_t dart::Function::KernelLibraryOffset ( ) const

Definition at line 10999 of file object.cc.

                                             {
  const intptr_t kernel_library_index = KernelLibraryIndex();
  if (kernel_library_index == -1) return 0;
  const auto& info = KernelProgramInfo::Handle(KernelProgramInfo());
  return info.KernelLibraryStartOffset(kernel_library_index);
}

◆ KernelProgramInfo()

KernelProgramInfoPtr dart::Function::KernelProgramInfo ( ) const

Definition at line 10977 of file object.cc.

                                                       {
  if (is_eval_function()) {
    const auto& fdata = Array::Handle(Array::RawCast(data()));
    return KernelProgramInfo::RawCast(
        fdata.At(static_cast<intptr_t>(EvalFunctionData::kKernelProgramInfo)));
  }
  if (IsClosureFunction()) {
    const auto& parent = Function::Handle(parent_function());
    return parent.KernelProgramInfo();
  }
  const auto& owner = Object::Handle(RawOwner());
  if (owner.IsClass()) {
    return Class::Cast(owner).KernelProgramInfo();
  }
  return PatchClass::Cast(owner).kernel_program_info();
}

◆ kind()

UntaggedFunction::Kind dart::Function::kind ( ) const

inline

Definition at line 3329 of file object.h.

3329{ return KindOf(ptr()); }

◆ kind_tag_offset()

static intptr_t dart::Function::kind_tag_offset ( )

inlinestatic

Definition at line 4106 of file object.h.

                                    {
    return OFFSET_OF(UntaggedFunction, kind_tag_);
  }

◆ KindOf()

static UntaggedFunction::Kind dart::Function::KindOf ( FunctionPtr func )

inlinestatic

Definition at line 3330 of file object.h.

                                                       {
    return func->untag()->kind_tag_.Read<KindBits>();
  }

◆ KindToCString()

const char * dart::Function::KindToCString ( UntaggedFunction::Kind kind )

static

Definition at line 8477 of file object.cc.

                                                             {
  return UntaggedFunction::KindToCString(kind);
}

◆ MakesCopyOfParameters()

bool dart::Function::MakesCopyOfParameters ( ) const

inline

Definition at line 3494 of file object.h.

                                     {
    return HasOptionalParameters() || IsSuspendableFunction();
  }

◆ maximum_unboxed_parameter_count()

static constexpr intptr_t dart::Function::maximum_unboxed_parameter_count ( )

inlinestaticconstexpr

Definition at line 3684 of file object.h.

                                                              {
    // Subtracts one that represents the return value
    return UntaggedFunction::UnboxedParameterBitmap::kCapacity - 1;
  }

◆ MaxNumberOfParametersInRegisters()

intptr_t dart::Function::MaxNumberOfParametersInRegisters ( Zone * zone ) const

Definition at line 27324 of file object.cc.

                                                                    {
#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64) ||                  \
    defined(TARGET_ARCH_ARM)
  if (!FLAG_precompiled_mode) {
    return 0;
  }
 
  if (!FLAG_use_register_cc) {
    return 0;
  }
 
  if (IsGeneric()) {
    return 0;
  }
 
  switch (kind()) {
    case UntaggedFunction::kClosureFunction:
    case UntaggedFunction::kImplicitClosureFunction:
    case UntaggedFunction::kNoSuchMethodDispatcher:
    case UntaggedFunction::kInvokeFieldDispatcher:
    case UntaggedFunction::kDynamicInvocationForwarder:
    case UntaggedFunction::kMethodExtractor:
    case UntaggedFunction::kFfiTrampoline:
    case UntaggedFunction::kFieldInitializer:
    case UntaggedFunction::kIrregexpFunction:
      return 0;
 
    default:
      break;
  }
 
  const auto unboxing_metadata = kernel::UnboxingInfoMetadataOf(*this, zone);
  if (unboxing_metadata != nullptr &&
      unboxing_metadata->must_use_stack_calling_convention) {
    return 0;
  }
 
  // Getters and setters have fixed signatures.
  switch (kind()) {
    case UntaggedFunction::kGetterFunction:
    case UntaggedFunction::kImplicitGetter:
    case UntaggedFunction::kSetterFunction:
    case UntaggedFunction::kImplicitSetter:
      return num_fixed_parameters();
 
    default:
      break;
  }
 
  if (unboxing_metadata != nullptr &&
      unboxing_metadata->has_overrides_with_less_direct_parameters) {
    // Receiver (`this`) can always be passed in the register because it is
    // never an optional or named parameter.
    return unboxing_metadata->unboxed_args_info.length() + 1;
  }
 
  return num_fixed_parameters();
#endif
  return 0;
}

◆ MayHaveUncheckedEntryPoint()

bool dart::Function::MayHaveUncheckedEntryPoint ( ) const

Definition at line 11499 of file object.cc.

                                                {
  return FLAG_enable_multiple_entrypoints &&
         (NeedsTypeArgumentTypeChecks() || NeedsArgumentTypeChecks());
}

◆ modifier()

UntaggedFunction::AsyncModifier dart::Function::modifier ( ) const

inline

Definition at line 3334 of file object.h.

                                                 {
    return untag()->kind_tag_.Read<ModifierBits>();
  }

◆ name()

StringPtr dart::Function::name ( ) const

inline

Definition at line 2972 of file object.h.

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

◆ NameCString()

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

Definition at line 11036 of file object.cc.

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

◆ native_name()

StringPtr dart::Function::native_name ( ) const

Definition at line 8564 of file object.cc.

                                      {
  ASSERT(is_native());
  const Object& obj = Object::Handle(data());
  ASSERT(obj.IsArray());
  return String::RawCast(Array::Cast(obj).At(0));
}

◆ NeedsArgumentTypeChecks()

bool dart::Function::NeedsArgumentTypeChecks ( ) const

inline

Definition at line 3416 of file object.h.

                                       {
    return !(is_static() || (kind() == UntaggedFunction::kConstructor));
  }

◆ NeedsMonomorphicCheckedEntry()

bool dart::Function::NeedsMonomorphicCheckedEntry ( Zone * zone ) const

Definition at line 11422 of file object.cc.

                                                            {
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (!IsDynamicFunction()) {
    return false;
  }
 
  // For functions which need an args descriptor the switchable call sites will
  // transition directly to calling via a stub (and therefore never call the
  // monomorphic entry).
  //
  // See runtime_entry.cc:DEFINE_RUNTIME_ENTRY(UnlinkedCall)
  if (PrologueNeedsArgumentsDescriptor()) {
    return false;
  }
 
  // All dyn:* forwarders are called via SwitchableCalls and all except the ones
  // with `PrologueNeedsArgumentsDescriptor()` transition into monomorphic
  // state.
  if (Function::IsDynamicInvocationForwarderName(name())) {
    return true;
  }
 
  // AOT mode uses table dispatch.
  // In JIT mode all instance calls use switchable calls.
  if (!FLAG_precompiled_mode) {
    return true;
  }
 
  // Only if there are dynamic callers and if we didn't create a dyn:* forwarder
  // for it do we need the monomorphic checked entry.
  return HasDynamicCallers(zone) &&
         !kernel::NeedsDynamicInvocationForwarder(*this);
#else
  UNREACHABLE();
  return true;
#endif
}

◆ NeedsTypeArgumentTypeChecks()

bool dart::Function::NeedsTypeArgumentTypeChecks ( ) const

inline

Definition at line 3412 of file object.h.

                                           {
    return !(is_static() || (kind() == UntaggedFunction::kConstructor));
  }

◆ New()

FunctionPtr dart::Function::New	(	const FunctionType &	signature,
		const String &	name,
		UntaggedFunction::Kind	kind,
		bool	is_static,
		bool	is_const,
		bool	is_abstract,
		bool	is_external,
		bool	is_native,
		const Object &	owner,
		TokenPosition	token_pos,
		Heap::Space	space = `Heap::kOld`
	)

static

Definition at line 10301 of file object.cc.

                                           {
  ASSERT(!owner.IsNull());
  ASSERT(!signature.IsNull());
  const Function& result = Function::Handle(Function::New(space));
  result.set_kind_tag(0);
  result.set_packed_fields(0);
  result.set_name(name);
  result.set_kind_tag(0);  // Ensure determinism of uninitialized bits.
  result.set_kind(kind);
  result.set_recognized_kind(MethodRecognizer::kUnknown);
  result.set_modifier(UntaggedFunction::kNoModifier);
  result.set_is_static(is_static);
  result.set_is_const(is_const);
  result.set_is_abstract(is_abstract);
  result.set_is_external(is_external);
  result.set_is_native(is_native);
  result.set_is_reflectable(true);  // Will be computed later.
  result.set_is_visible(true);      // Will be computed later.
  result.set_is_debuggable(true);   // Will be computed later.
  result.set_is_intrinsic(false);
  result.set_has_pragma(false);
  result.set_is_polymorphic_target(false);
  result.set_is_synthetic(false);
  NOT_IN_PRECOMPILED(result.set_state_bits(0));
  result.set_owner(owner);
  NOT_IN_PRECOMPILED(result.set_token_pos(token_pos));
  NOT_IN_PRECOMPILED(result.set_end_token_pos(token_pos));
  NOT_IN_PRECOMPILED(result.set_usage_counter(0));
  NOT_IN_PRECOMPILED(result.set_deoptimization_counter(0));
  NOT_IN_PRECOMPILED(result.set_optimized_instruction_count(0));
  NOT_IN_PRECOMPILED(result.set_optimized_call_site_count(0));
  NOT_IN_PRECOMPILED(result.set_inlining_depth(0));
  NOT_IN_PRECOMPILED(result.set_kernel_offset(0));
  result.set_is_optimizable(is_native ? false : true);
  result.set_is_inlinable(true);
  result.reset_unboxed_parameters_and_return();
  result.SetInstructionsSafe(StubCode::LazyCompile());
 
  // See Function::set_data() for more information.
  if (kind == UntaggedFunction::kClosureFunction ||
      kind == UntaggedFunction::kImplicitClosureFunction) {
    ASSERT(space == Heap::kOld);
    const ClosureData& data = ClosureData::Handle(ClosureData::New());
    data.set_awaiter_link({});
    result.set_data(data);
  } else if (kind == UntaggedFunction::kFfiTrampoline) {
    const FfiTrampolineData& data =
        FfiTrampolineData::Handle(FfiTrampolineData::New());
    result.set_data(data);
  } else if (result.is_old_native()) {
    const auto& data =
        Array::Handle(Array::New(NativeFunctionData::kLength, Heap::kOld));
    result.set_data(data);
  } else {
    // Functions other than signature functions have no reason to be allocated
    // in new space.
    ASSERT(space == Heap::kOld);
  }
 
  // Force-optimized functions are not debuggable because they cannot
  // deoptimize.
  if (result.ForceOptimize()) {
    result.set_is_debuggable(false);
  }
  signature.set_num_implicit_parameters(result.NumImplicitParameters());
  result.SetSignature(signature);
  NOT_IN_PRECOMPILED(
      result.set_positional_parameter_names(Object::empty_array()));
  return result.ptr();
}

◆ NewClosureFunction()

FunctionPtr dart::Function::NewClosureFunction	(	const String &	name,
		const Function &	parent,
		TokenPosition	token_pos
	)

static

Definition at line 10406 of file object.cc.

                                                                  {
  // Use the owner defining the parent function and not the class containing it.
  const Object& parent_owner = Object::Handle(parent.RawOwner());
  return NewClosureFunctionWithKind(UntaggedFunction::kClosureFunction, name,
                                    parent, parent.is_static(), token_pos,
                                    parent_owner);
}

◆ NewClosureFunctionWithKind()

FunctionPtr dart::Function::NewClosureFunctionWithKind	(	UntaggedFunction::Kind	kind,
		const String &	name,
		const Function &	parent,
		bool	is_static,
		TokenPosition	token_pos,
		const Object &	owner
	)

static

Definition at line 10382 of file object.cc.

                                                                      {
  ASSERT((kind == UntaggedFunction::kClosureFunction) ||
         (kind == UntaggedFunction::kImplicitClosureFunction));
  ASSERT(!parent.IsNull());
  ASSERT(!owner.IsNull());
  const FunctionType& signature = FunctionType::Handle(FunctionType::New(
      kind == UntaggedFunction::kClosureFunction ? parent.NumTypeArguments()
                                                 : 0));
  const Function& result = Function::Handle(
      Function::New(signature, name, kind,
                    /* is_static = */ is_static,
                    /* is_const = */ false,
                    /* is_abstract = */ false,
                    /* is_external = */ false,
                    /* is_native = */ false, owner, token_pos));
  result.set_parent_function(parent);
  return result.ptr();
}

◆ NewImplicitClosureFunction()

FunctionPtr dart::Function::NewImplicitClosureFunction	(	const String &	name,
		const Function &	parent,
		TokenPosition	token_pos
	)

static

Definition at line 10416 of file object.cc.

                                                                          {
  // Use the owner defining the parent function and not the class containing it.
  const Object& parent_owner = Object::Handle(parent.RawOwner());
  return NewClosureFunctionWithKind(
      UntaggedFunction::kImplicitClosureFunction, name, parent,
      parent.is_static() || parent.IsConstructor(), token_pos, parent_owner);
}

◆ num_fixed_parameters()

intptr_t dart::Function::num_fixed_parameters ( ) const

Definition at line 8914 of file object.cc.

                                              {
  return FunctionType::NumFixedParametersOf(signature());
}

◆ NumImplicitParameters()

intptr_t dart::Function::NumImplicitParameters ( ) const

Definition at line 9286 of file object.cc.

                                               {
  const UntaggedFunction::Kind k = kind();
  if (k == UntaggedFunction::kConstructor) {
    // Type arguments for factory; instance for generative constructor.
    return 1;
  }
  if ((k == UntaggedFunction::kClosureFunction) ||
      (k == UntaggedFunction::kImplicitClosureFunction) ||
      (k == UntaggedFunction::kFfiTrampoline)) {
    return 1;  // Closure object.
  }
  if (!is_static()) {
    // Closure functions defined inside instance (i.e. non-static) functions are
    // marked as non-static, but they do not have a receiver.
    // Closures are handled above.
    ASSERT((k != UntaggedFunction::kClosureFunction) &&
           (k != UntaggedFunction::kImplicitClosureFunction));
    return 1;  // Receiver.
  }
  return 0;  // No implicit parameters.
}

◆ NumOptionalNamedParameters()

intptr_t dart::Function::NumOptionalNamedParameters ( ) const

Definition at line 8932 of file object.cc.

                                                    {
  return FunctionType::NumOptionalNamedParametersOf(signature());
}

◆ NumOptionalParameters()

intptr_t dart::Function::NumOptionalParameters ( ) const

Definition at line 8926 of file object.cc.

                                               {
  return FunctionType::NumOptionalParametersOf(signature());
}

◆ NumOptionalPositionalParameters()

intptr_t dart::Function::NumOptionalPositionalParameters ( ) const

Definition at line 8929 of file object.cc.

                                                         {
  return FunctionType::NumOptionalPositionalParametersOf(signature());
}

◆ NumParameters()

intptr_t dart::Function::NumParameters ( ) const

Definition at line 8935 of file object.cc.

                                       {
  return FunctionType::NumParametersOf(signature());
}

◆ NumParentTypeArguments()

intptr_t dart::Function::NumParentTypeArguments ( ) const

Definition at line 8908 of file object.cc.

                                                {
  return FunctionType::NumParentTypeArgumentsOf(signature());
}

◆ NumTypeArguments()

intptr_t dart::Function::NumTypeArguments ( ) const

Definition at line 8911 of file object.cc.

                                          {
  return FunctionType::NumTypeArgumentsOf(signature());
}

◆ NumTypeParameters()

intptr_t dart::Function::NumTypeParameters ( ) const

Definition at line 8905 of file object.cc.

                                           {
  return FunctionType::NumTypeParametersOf(signature());
}

◆ Owner()

ClassPtr dart::Function::Owner ( ) const

Definition at line 10899 of file object.cc.

                               {
  ASSERT(untag()->owner() != Object::null());
  if (untag()->owner()->IsClass()) {
    return Class::RawCast(untag()->owner());
  }
  const Object& obj = Object::Handle(untag()->owner());
  ASSERT(obj.IsPatchClass());
  return PatchClass::Cast(obj).wrapped_class();
}

◆ packed_fields()

uint32_t dart::Function::packed_fields ( ) const

inline

Definition at line 3462 of file object.h.

                                 {
#if defined(DART_PRECOMPILED_RUNTIME)
    UNREACHABLE();
#else
    return untag()->packed_fields_;
#endif
  }

◆ parameter_types()

ArrayPtr dart::Function::parameter_types ( ) const

inline

Definition at line 3087 of file object.h.

                                   {
    return signature()->untag()->parameter_types();
  }

◆ ParameterNameAt()

StringPtr dart::Function::ParameterNameAt ( intptr_t index ) const

Definition at line 8660 of file object.cc.

                                                        {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    // Without the signature, we're guaranteed not to have any name information.
    return Symbols::OptimizedOut().ptr();
  }
#endif
  const intptr_t num_fixed = num_fixed_parameters();
  if (HasOptionalNamedParameters() && index >= num_fixed) {
    const Array& parameter_names =
        Array::Handle(signature()->untag()->named_parameter_names());
    return String::RawCast(parameter_names.At(index - num_fixed));
  }
#if defined(DART_PRECOMPILED_RUNTIME)
  return Symbols::OptimizedOut().ptr();
#else
  const Array& names = Array::Handle(untag()->positional_parameter_names());
  return String::RawCast(names.At(index));
#endif
}

◆ ParameterTypeAt()

AbstractTypePtr dart::Function::ParameterTypeAt ( intptr_t index ) const

Definition at line 8638 of file object.cc.

                                                              {
  const Array& types = Array::Handle(parameter_types());
  return AbstractType::RawCast(types.At(index));
}

◆ parent_function()

FunctionPtr dart::Function::parent_function ( ) const

Definition at line 8225 of file object.cc.

                                            {
  if (!IsClosureFunction()) return Function::null();
  Object& obj = Object::Handle(untag()->data());
  ASSERT(!obj.IsNull());
  return ClosureData::Cast(obj).parent_function();
}

◆ PRECOMPILER_WSR_FIELD_DECLARATION()

dart::Function::PRECOMPILER_WSR_FIELD_DECLARATION	(	FunctionType	,
		signature
	)

◆ PrintName()

void dart::Function::PrintName	(	const NameFormattingParams &	params,
		BaseTextBuffer *	printer
	)		const

Definition at line 11167 of file object.cc.

                                                        {
  if (!IsLocalFunction()) {
    FunctionPrintNameHelper(*this, params, printer);
    return;
  }
  auto& fun = Function::Handle(ptr());
  FunctionPrintNameHelper(fun, params, printer);
}

◆ PrologueNeedsArgumentsDescriptor()

bool dart::Function::PrologueNeedsArgumentsDescriptor ( ) const

Definition at line 11488 of file object.cc.

                                                      {
  // These functions have a saved compile-time arguments descriptor that is
  // used in lieu of the runtime arguments descriptor in generated IL.
  if (HasSavedArgumentsDescriptor()) {
    return false;
  }
  // The prologue of those functions need to examine the arg descriptor for
  // various purposes.
  return IsGeneric() || HasOptionalParameters();
}

◆ QualifiedScrubbedName()

StringPtr dart::Function::QualifiedScrubbedName ( ) const

Definition at line 11067 of file object.cc.

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

◆ QualifiedScrubbedNameCString()

const char * dart::Function::QualifiedScrubbedNameCString ( ) const

Definition at line 11074 of file object.cc.

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

◆ QualifiedUserVisibleName()

StringPtr dart::Function::QualifiedUserVisibleName ( ) const

Definition at line 11081 of file object.cc.

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

◆ QualifiedUserVisibleNameCString()

const char * dart::Function::QualifiedUserVisibleNameCString ( ) const

Definition at line 11088 of file object.cc.

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

◆ RawOwner()

ObjectPtr dart::Function::RawOwner ( ) const

inline

Definition at line 3063 of file object.h.

3063{ return untag()->owner(); }

◆ recognized_kind()

MethodRecognizer::Kind dart::Function::recognized_kind ( ) const

inline

Definition at line 3599 of file object.h.

                                               {
    return untag()->kind_tag_.Read<RecognizedBits>();
  }

◆ RecognizedKindForceOptimize()

bool dart::Function::RecognizedKindForceOptimize ( ) const

Definition at line 9144 of file object.cc.

                                                 {
  switch (recognized_kind()) {
    // Uses unboxed/untagged data not supported in unoptimized, or uses
    // LoadIndexed/StoreIndexed/MemoryCopy instructions with typed data
    // arrays, which requires optimization for payload extraction.
    case MethodRecognizer::kObjectArrayGetIndexed:
    case MethodRecognizer::kGrowableArrayGetIndexed:
#define TYPED_DATA_GET_INDEXED_CASES(clazz)                                    \
  case MethodRecognizer::k##clazz##ArrayGetIndexed:                            \
    FALL_THROUGH;                                                              \
  case MethodRecognizer::kExternal##clazz##ArrayGetIndexed:                    \
    FALL_THROUGH;                                                              \
  case MethodRecognizer::k##clazz##ArrayViewGetIndexed:                        \
    FALL_THROUGH;
      DART_CLASS_LIST_TYPED_DATA(TYPED_DATA_GET_INDEXED_CASES)
#undef TYPED_DATA_GET_INDEXED_CASES
    case MethodRecognizer::kCopyRangeFromUint8ListToOneByteString:
    case MethodRecognizer::kFinalizerBase_getIsolateFinalizers:
    case MethodRecognizer::kFinalizerBase_setIsolate:
    case MethodRecognizer::kFinalizerBase_setIsolateFinalizers:
    case MethodRecognizer::kFinalizerEntry_getExternalSize:
    case MethodRecognizer::kExtensionStreamHasListener:
    case MethodRecognizer::kFfiLoadInt8:
    case MethodRecognizer::kFfiLoadInt16:
    case MethodRecognizer::kFfiLoadInt32:
    case MethodRecognizer::kFfiLoadInt64:
    case MethodRecognizer::kFfiLoadUint8:
    case MethodRecognizer::kFfiLoadUint16:
    case MethodRecognizer::kFfiLoadUint32:
    case MethodRecognizer::kFfiLoadUint64:
    case MethodRecognizer::kFfiLoadFloat:
    case MethodRecognizer::kFfiLoadFloatUnaligned:
    case MethodRecognizer::kFfiLoadDouble:
    case MethodRecognizer::kFfiLoadDoubleUnaligned:
    case MethodRecognizer::kFfiLoadPointer:
    case MethodRecognizer::kFfiStoreInt8:
    case MethodRecognizer::kFfiStoreInt16:
    case MethodRecognizer::kFfiStoreInt32:
    case MethodRecognizer::kFfiStoreInt64:
    case MethodRecognizer::kFfiStoreUint8:
    case MethodRecognizer::kFfiStoreUint16:
    case MethodRecognizer::kFfiStoreUint32:
    case MethodRecognizer::kFfiStoreUint64:
    case MethodRecognizer::kFfiStoreFloat:
    case MethodRecognizer::kFfiStoreFloatUnaligned:
    case MethodRecognizer::kFfiStoreDouble:
    case MethodRecognizer::kFfiStoreDoubleUnaligned:
    case MethodRecognizer::kFfiStorePointer:
    case MethodRecognizer::kFfiFromAddress:
    case MethodRecognizer::kFfiGetAddress:
    case MethodRecognizer::kFfiAsExternalTypedDataInt8:
    case MethodRecognizer::kFfiAsExternalTypedDataInt16:
    case MethodRecognizer::kFfiAsExternalTypedDataInt32:
    case MethodRecognizer::kFfiAsExternalTypedDataInt64:
    case MethodRecognizer::kFfiAsExternalTypedDataUint8:
    case MethodRecognizer::kFfiAsExternalTypedDataUint16:
    case MethodRecognizer::kFfiAsExternalTypedDataUint32:
    case MethodRecognizer::kFfiAsExternalTypedDataUint64:
    case MethodRecognizer::kFfiAsExternalTypedDataFloat:
    case MethodRecognizer::kFfiAsExternalTypedDataDouble:
    case MethodRecognizer::kGetNativeField:
    case MethodRecognizer::kRecord_fieldNames:
    case MethodRecognizer::kRecord_numFields:
    case MethodRecognizer::kStringBaseCodeUnitAt:
    case MethodRecognizer::kUtf8DecoderScan:
    case MethodRecognizer::kDouble_hashCode:
    case MethodRecognizer::kTypedList_GetInt8:
    case MethodRecognizer::kTypedList_SetInt8:
    case MethodRecognizer::kTypedList_GetUint8:
    case MethodRecognizer::kTypedList_SetUint8:
    case MethodRecognizer::kTypedList_GetInt16:
    case MethodRecognizer::kTypedList_SetInt16:
    case MethodRecognizer::kTypedList_GetUint16:
    case MethodRecognizer::kTypedList_SetUint16:
    case MethodRecognizer::kTypedList_GetInt32:
    case MethodRecognizer::kTypedList_SetInt32:
    case MethodRecognizer::kTypedList_GetUint32:
    case MethodRecognizer::kTypedList_SetUint32:
    case MethodRecognizer::kTypedList_GetInt64:
    case MethodRecognizer::kTypedList_SetInt64:
    case MethodRecognizer::kTypedList_GetUint64:
    case MethodRecognizer::kTypedList_SetUint64:
    case MethodRecognizer::kTypedList_GetFloat32:
    case MethodRecognizer::kTypedList_SetFloat32:
    case MethodRecognizer::kTypedList_GetFloat64:
    case MethodRecognizer::kTypedList_SetFloat64:
    case MethodRecognizer::kTypedList_GetInt32x4:
    case MethodRecognizer::kTypedList_SetInt32x4:
    case MethodRecognizer::kTypedList_GetFloat32x4:
    case MethodRecognizer::kTypedList_SetFloat32x4:
    case MethodRecognizer::kTypedList_GetFloat64x2:
    case MethodRecognizer::kTypedList_SetFloat64x2:
    case MethodRecognizer::kTypedData_memMove1:
    case MethodRecognizer::kTypedData_memMove2:
    case MethodRecognizer::kTypedData_memMove4:
    case MethodRecognizer::kTypedData_memMove8:
    case MethodRecognizer::kTypedData_memMove16:
    case MethodRecognizer::kMemCopy:
    // Prevent the GC from running so that the operation is atomic from
    // a GC point of view. Always double check implementation in
    // kernel_to_il.cc that no GC can happen in between the relevant IL
    // instructions.
    // TODO(https://dartbug.com/48527): Support inlining.
    case MethodRecognizer::kFinalizerBase_exchangeEntriesCollectedWithNull:
    // Both unboxed/untagged data and atomic-to-GC operation.
    case MethodRecognizer::kFinalizerEntry_allocate:
      return true;
    default:
      return false;
  }
}

◆ regexp()

RegExpPtr dart::Function::regexp ( ) const

Definition at line 8527 of file object.cc.

                                 {
  ASSERT(kind() == UntaggedFunction::kIrregexpFunction);
  const Array& pair = Array::Cast(Object::Handle(data()));
  return RegExp::RawCast(pair.At(0));
}

◆ reset_unboxed_parameters_and_return()

void dart::Function::reset_unboxed_parameters_and_return ( ) const

inline

Definition at line 3689 of file object.h.

                                                   {
#if !defined(DART_PRECOMPILED_RUNTIME)
    StoreNonPointer(&untag()->unboxed_parameters_info_,
                    UntaggedFunction::UnboxedParameterBitmap());
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ RestoreICDataMap()

void dart::Function::RestoreICDataMap	(	ZoneGrowableArray< const ICData * > *	deopt_id_to_ic_data,
		bool	clone_ic_data
	)		const

Definition at line 11275 of file object.cc.

                              {
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (FLAG_force_clone_compiler_objects) {
    clone_ic_data = true;
  }
  ASSERT(deopt_id_to_ic_data->is_empty());
  Zone* zone = Thread::Current()->zone();
  const Array& saved_ic_data = Array::Handle(zone, ic_data_array());
  if (saved_ic_data.IsNull()) {
    // Could happen with not-yet compiled unoptimized code or force-optimized
    // functions.
    return;
  }
  const intptr_t saved_length = saved_ic_data.Length();
  ASSERT(saved_length > 0);
  if (saved_length > ICDataArrayIndices::kFirstICData) {
    const intptr_t restored_length =
        ICData::Cast(Object::Handle(zone, saved_ic_data.At(saved_length - 1)))
            .deopt_id() +
        1;
    deopt_id_to_ic_data->SetLength(restored_length);
    for (intptr_t i = 0; i < restored_length; i++) {
      (*deopt_id_to_ic_data)[i] = nullptr;
    }
    for (intptr_t i = ICDataArrayIndices::kFirstICData; i < saved_length; i++) {
      ICData& ic_data = ICData::ZoneHandle(zone);
      ic_data ^= saved_ic_data.At(i);
      if (clone_ic_data) {
        const ICData& original_ic_data = ICData::Handle(zone, ic_data.ptr());
        ic_data = ICData::Clone(ic_data);
        ic_data.SetOriginal(original_ic_data);
      }
      ASSERT(deopt_id_to_ic_data->At(ic_data.deopt_id()) == nullptr);
      (*deopt_id_to_ic_data)[ic_data.deopt_id()] = &ic_data;
    }
  }
#else   // DART_PRECOMPILED_RUNTIME
  UNREACHABLE();
#endif  // DART_PRECOMPILED_RUNTIME
}

◆ result_type()

AbstractTypePtr dart::Function::result_type ( ) const

inline

Definition at line 3079 of file object.h.

                                      {
    return signature()->untag()->result_type();
  }

◆ SafeToClosurize()

bool dart::Function::SafeToClosurize ( ) const

Definition at line 10426 of file object.cc.

                                     {
#if defined(DART_PRECOMPILED_RUNTIME)
  return HasImplicitClosureFunction();
#else
  return true;
#endif
}

◆ saved_args_desc()

ArrayPtr dart::Function::saved_args_desc ( ) const

Definition at line 8191 of file object.cc.

                                         {
  if (kind() == UntaggedFunction::kDynamicInvocationForwarder) {
    return Array::null();
  }
  ASSERT(kind() == UntaggedFunction::kNoSuchMethodDispatcher ||
         kind() == UntaggedFunction::kInvokeFieldDispatcher);
  return Array::RawCast(untag()->data());
}

◆ SaveICDataMap()

void dart::Function::SaveICDataMap	(	const ZoneGrowableArray< const ICData * > &	deopt_id_to_ic_data,
		const Array &	edge_counters_array,
		const Array &	coverage_array
	)		const

Definition at line 11236 of file object.cc.

                                       {
#if !defined(DART_PRECOMPILED_RUNTIME)
  // Already installed nothing to do.
  if (ic_data_array() != Array::null()) {
    ASSERT(coverage_array.ptr() == GetCoverageArray());
    return;
  }
 
  // Compute number of ICData objects to save.
  intptr_t count = 0;
  for (intptr_t i = 0; i < deopt_id_to_ic_data.length(); i++) {
    if (deopt_id_to_ic_data[i] != nullptr) {
      count++;
    }
  }
 
  // Compress sparse deopt_id_to_ic_data mapping into a linear sequence of
  // ICData objects.
  const Array& array = Array::Handle(
      Array::New(ICDataArrayIndices::kFirstICData + count, Heap::kOld));
  for (intptr_t i = 0, pos = ICDataArrayIndices::kFirstICData;
       i < deopt_id_to_ic_data.length(); i++) {
    if (deopt_id_to_ic_data[i] != nullptr) {
      ASSERT(i == deopt_id_to_ic_data[i]->deopt_id());
      array.SetAt(pos++, *deopt_id_to_ic_data[i]);
    }
  }
  array.SetAt(ICDataArrayIndices::kEdgeCounters, edge_counters_array);
  // Preserve coverage_array which is stored early after graph construction.
  array.SetAt(ICDataArrayIndices::kCoverageData, coverage_array);
  set_ic_data_array(array);
#else   // DART_PRECOMPILED_RUNTIME
  UNREACHABLE();
#endif  // DART_PRECOMPILED_RUNTIME
}

◆ script()

ScriptPtr dart::Function::script ( ) const

Definition at line 10939 of file object.cc.

                                 {
  // NOTE(turnidge): If you update this function, you probably want to
  // update Class::PatchFieldsAndFunctions() at the same time.
  if (IsDynamicInvocationForwarder()) {
    const Function& target = Function::Handle(ForwardingTarget());
    return target.IsNull() ? Script::null() : target.script();
  }
  if (IsImplicitGetterOrSetter()) {
    const auto& field = Field::Handle(accessor_field());
    return field.IsNull() ? Script::null() : field.Script();
  }
  if (is_eval_function()) {
    const auto& fdata = Array::Handle(Array::RawCast(data()));
    return Script::RawCast(
        fdata.At(static_cast<intptr_t>(EvalFunctionData::kScript)));
  }
  if (token_pos() == TokenPosition::kMinSource) {
    // Testing for position 0 is an optimization that relies on temporary
    // eval functions having token position 0.
    const Script& script = Script::Handle(eval_script());
    if (!script.IsNull()) {
      return script.ptr();
    }
  }
  const Object& obj = Object::Handle(untag()->owner());
  if (obj.IsPatchClass()) {
    return PatchClass::Cast(obj).script();
  }
  if (IsClosureFunction()) {
    const Function& function = Function::Handle(parent_function());
    if (function.IsNull()) return Script::null();
    return function.script();
  }
  ASSERT(obj.IsClass());
  return Class::Cast(obj).script();
}

◆ set_accessor_field()

void dart::Function::set_accessor_field ( const Field & value ) const

Definition at line 8215 of file object.cc.

                                                          {
  ASSERT(kind() == UntaggedFunction::kImplicitGetter ||
         kind() == UntaggedFunction::kImplicitSetter ||
         kind() == UntaggedFunction::kImplicitStaticGetter ||
         kind() == UntaggedFunction::kFieldInitializer);
  // Top level classes may be finalized multiple times.
  ASSERT(untag()->data() == Object::null() || untag()->data() == value.ptr());
  set_data(value);
}

◆ set_awaiter_link()

void dart::Function::set_awaiter_link ( Function::AwaiterLink link ) const

Definition at line 8135 of file object.cc.

                                                              {
  if (IsClosureFunction()) {
    const Object& obj = Object::Handle(untag()->data());
    ASSERT(!obj.IsNull());
    ClosureData::Cast(obj).set_awaiter_link(link);
    return;
  }
  UNREACHABLE();
}

◆ set_context_scope()

void dart::Function::set_context_scope ( const ContextScope & value ) const

Definition at line 8115 of file object.cc.

                                                                {
  if (IsClosureFunction()) {
    const Object& obj = Object::Handle(untag()->data());
    ASSERT(!obj.IsNull());
    ClosureData::Cast(obj).set_context_scope(value);
    return;
  }
  UNREACHABLE();
}

◆ set_default_type_arguments_instantiation_mode()

void dart::Function::set_default_type_arguments_instantiation_mode ( InstantiationMode value ) const

Definition at line 8254 of file object.cc.

                                   {
  if (!IsClosureFunction()) {
    UNREACHABLE();
  }
  const auto& closure_data = ClosureData::Handle(ClosureData::RawCast(data()));
  ASSERT(!closure_data.IsNull());
  closure_data.set_default_type_arguments_instantiation_mode(value);
}

◆ set_end_token_pos()

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

inline

Definition at line 3442 of file object.h.

                                                    {
#if defined(DART_PRECOMPILED_RUNTIME)
    UNREACHABLE();
#else
    StoreNonPointer(&untag()->end_token_pos_, value);
#endif
  }

◆ set_extracted_method_closure()

void dart::Function::set_extracted_method_closure ( const Function & function ) const

Definition at line 8185 of file object.cc.

                                                                       {
  ASSERT(kind() == UntaggedFunction::kMethodExtractor);
  ASSERT(untag()->data() == Object::null());
  set_data(value);
}

◆ set_is_optimizable()

void dart::Function::set_is_optimizable ( bool value ) const

inline

Definition at line 4185 of file object.h.

                                            {
#if defined(DART_PRECOMPILED_RUNTIME)
    UNREACHABLE();
#else
    untag()->packed_fields_.UpdateBool<UntaggedFunction::PackedOptimizable>(
        value);
#endif
  }

◆ set_kernel_offset()

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

inline

Definition at line 3538 of file object.h.

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

◆ set_modifier()

void dart::Function::set_modifier ( UntaggedFunction::AsyncModifier value ) const

Definition at line 8949 of file object.cc.

                                                                     {
  untag()->kind_tag_.Update<ModifierBits>(value);
}

◆ set_native_name()

void dart::Function::set_native_name ( const String & name ) const

Definition at line 8571 of file object.cc.

                                                        {
  ASSERT(is_native());
  const auto& pair = Array::Cast(Object::Handle(data()));
  ASSERT(pair.At(0) == Object::null());
  pair.SetAt(NativeFunctionData::kNativeName, value);
}

◆ set_owner()

void dart::Function::set_owner ( const Object & value ) const

Definition at line 8522 of file object.cc.

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

◆ set_packed_fields()

void dart::Function::set_packed_fields ( uint32_t packed_fields ) const

Definition at line 8980 of file object.cc.

                                                             {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  StoreNonPointer(&untag()->packed_fields_, packed_fields);
#endif
}

◆ set_recognized_kind()

void dart::Function::set_recognized_kind ( MethodRecognizer::Kind value ) const

Definition at line 8953 of file object.cc.

                                                                   {
  // Prevent multiple settings of kind.
  ASSERT((value == MethodRecognizer::kUnknown) || !IsRecognized());
  untag()->kind_tag_.Update<RecognizedBits>(value);
}

◆ set_saved_args_desc()

void dart::Function::set_saved_args_desc ( const Array & array ) const

Definition at line 8200 of file object.cc.

                                                           {
  ASSERT(kind() == UntaggedFunction::kNoSuchMethodDispatcher ||
         kind() == UntaggedFunction::kInvokeFieldDispatcher);
  ASSERT(untag()->data() == Object::null());
  set_data(value);
}

◆ set_token_pos()

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

Definition at line 8959 of file object.cc.

                                                          {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  ASSERT(!token_pos.IsClassifying() || IsMethodExtractor());
  StoreNonPointer(&untag()->token_pos_, token_pos);
#endif
}

◆ set_unboxed_double_parameter_at()

void dart::Function::set_unboxed_double_parameter_at ( intptr_t index ) const

inline

Definition at line 3708 of file object.h.

                                                             {
#if !defined(DART_PRECOMPILED_RUNTIME)
    ASSERT(index >= 0 && index < maximum_unboxed_parameter_count());
    index++;  // position 0 is reserved for the return value
    const_cast<UntaggedFunction::UnboxedParameterBitmap*>(
        &untag()->unboxed_parameters_info_)
        ->SetUnboxedDouble(index);
 
#else
    UNREACHABLE();
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ set_unboxed_double_return()

void dart::Function::set_unboxed_double_return ( ) const

inline

Definition at line 3731 of file object.h.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
    const_cast<UntaggedFunction::UnboxedParameterBitmap*>(
        &untag()->unboxed_parameters_info_)
        ->SetUnboxedDouble(0);
 
#else
    UNREACHABLE();
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ set_unboxed_integer_parameter_at()

void dart::Function::set_unboxed_integer_parameter_at ( intptr_t index ) const

inline

Definition at line 3696 of file object.h.

                                                              {
#if !defined(DART_PRECOMPILED_RUNTIME)
    ASSERT(index >= 0 && index < maximum_unboxed_parameter_count());
    index++;  // position 0 is reserved for the return value
    const_cast<UntaggedFunction::UnboxedParameterBitmap*>(
        &untag()->unboxed_parameters_info_)
        ->SetUnboxedInteger(index);
#else
    UNREACHABLE();
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ set_unboxed_integer_return()

void dart::Function::set_unboxed_integer_return ( ) const

inline

Definition at line 3721 of file object.h.

                                          {
#if !defined(DART_PRECOMPILED_RUNTIME)
    const_cast<UntaggedFunction::UnboxedParameterBitmap*>(
        &untag()->unboxed_parameters_info_)
        ->SetUnboxedInteger(0);
#else
    UNREACHABLE();
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ set_unboxed_record_return()

void dart::Function::set_unboxed_record_return ( ) const

inline

Definition at line 3742 of file object.h.

                                         {
#if !defined(DART_PRECOMPILED_RUNTIME)
    const_cast<UntaggedFunction::UnboxedParameterBitmap*>(
        &untag()->unboxed_parameters_info_)
        ->SetUnboxedRecord(0);
 
#else
    UNREACHABLE();
#endif  //  !defined(DART_PRECOMPILED_RUNTIME)
  }

◆ set_unoptimized_code()

void dart::Function::set_unoptimized_code ( const Code & value ) const

Definition at line 8096 of file object.cc.

                                                           {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  DEBUG_ASSERT(IsMutatorOrAtDeoptSafepoint());
  ASSERT(value.IsNull() || !value.is_optimized());
  untag()->set_unoptimized_code(value.ptr());
#endif
}

◆ SetDeoptReasonForAll()

void dart::Function::SetDeoptReasonForAll	(	intptr_t	deopt_id,
		ICData::DeoptReasonId	reason
	)

Definition at line 11350 of file object.cc.

                                                                {
  const Array& array = Array::Handle(ic_data_array());
  ICData& ic_data = ICData::Handle();
  for (intptr_t i = ICDataArrayIndices::kFirstICData; i < array.Length(); i++) {
    ic_data ^= array.At(i);
    if (ic_data.deopt_id() == deopt_id) {
      ic_data.AddDeoptReason(reason);
    }
  }
}

◆ SetFfiCallbackExceptionalReturn()

void dart::Function::SetFfiCallbackExceptionalReturn ( const Instance & value ) const

Definition at line 8456 of file object.cc.

                                                                          {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  FfiTrampolineData::Cast(obj).set_callback_exceptional_return(value);
}

◆ SetFfiCallbackKind()

void dart::Function::SetFfiCallbackKind ( FfiCallbackKind value ) const

Definition at line 8470 of file object.cc.

                                                             {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  FfiTrampolineData::Cast(obj).set_ffi_function_kind(value);
}

◆ SetFfiCallbackTarget()

void dart::Function::SetFfiCallbackTarget ( const Function & target ) const

Definition at line 8442 of file object.cc.

                                                                {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  FfiTrampolineData::Cast(obj).set_callback_target(target);
}

◆ SetFfiCSignature()

void dart::Function::SetFfiCSignature ( const FunctionType & sig ) const

Definition at line 8315 of file object.cc.

                                                             {
  ASSERT(IsFfiCallbackTrampoline());
  const Object& obj = Object::Handle(data());
  ASSERT(!obj.IsNull());
  FfiTrampolineData::Cast(obj).set_c_signature(sig);
}

◆ SetForwardingTarget()

void dart::Function::SetForwardingTarget ( const Function & target ) const

Definition at line 8486 of file object.cc.

                                                               {
  ASSERT(kind() == UntaggedFunction::kDynamicInvocationForwarder);
  set_data(target);
}

◆ SetInstructions()

void dart::Function::SetInstructions ( const Code & value ) const

Definition at line 7967 of file object.cc.

                                                      {
  // Ensure that nobody is executing this function when we install it.
  if (untag()->code() != Code::null() && HasCode()) {
    GcSafepointOperationScope safepoint(Thread::Current());
    SetInstructionsSafe(value);
  } else {
    ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
    SetInstructionsSafe(value);
  }
}

◆ SetInstructionsSafe()

void dart::Function::SetInstructionsSafe ( const Code & value ) const

Definition at line 7978 of file object.cc.

                                                          {
  untag()->set_code(value.ptr());
  StoreNonPointer(&untag()->entry_point_, value.EntryPoint());
  StoreNonPointer(&untag()->unchecked_entry_point_,
                  value.UncheckedEntryPoint());
}

◆ SetIsOptimizable()

void dart::Function::SetIsOptimizable ( bool value ) const

Definition at line 9006 of file object.cc.

                                                {
  ASSERT(!is_native());
  set_is_optimizable(value);
  if (!value) {
    set_is_inlinable(false);
    set_usage_counter(INT32_MIN);
  }
}

◆ SetKernelLibraryAndEvalScript()

void dart::Function::SetKernelLibraryAndEvalScript	(	const Script &	script,
		const class KernelProgramInfo &	kernel_program_info,
		intptr_t	index
	)		const

Definition at line 10925 of file object.cc.

                          {
  Array& data_field = Array::Handle(
      Array::New(static_cast<intptr_t>(EvalFunctionData::kLength)));
  data_field.SetAt(static_cast<intptr_t>(EvalFunctionData::kScript), script);
  data_field.SetAt(static_cast<intptr_t>(EvalFunctionData::kKernelProgramInfo),
                   kernel_program_info);
  data_field.SetAt(static_cast<intptr_t>(EvalFunctionData::kKernelLibraryIndex),
                   Smi::Handle(Smi::New(index)));
  set_data(data_field);
}

◆ SetOptimizedCallSiteCountClamped()

void dart::Function::SetOptimizedCallSiteCountClamped ( uintptr_t value ) const

inline

Definition at line 3557 of file object.h.

                                                               {
    if (value > kMaxInstructionCount) value = kMaxInstructionCount;
    set_optimized_call_site_count(value);
  }

◆ SetOptimizedInstructionCountClamped()

void dart::Function::SetOptimizedInstructionCountClamped ( uintptr_t value ) const

inline

Definition at line 3552 of file object.h.

                                                                  {
    if (value > kMaxInstructionCount) value = kMaxInstructionCount;
    set_optimized_instruction_count(value);
  }

◆ SetParameterNameAt()

void dart::Function::SetParameterNameAt	(	intptr_t	index,
		const String &	value
	)		const

Definition at line 8681 of file object.cc.

                                                                           {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  ASSERT(!value.IsNull() && value.IsSymbol());
  if (HasOptionalNamedParameters() && index >= num_fixed_parameters()) {
    // These should be set on the signature, not the function.
    UNREACHABLE();
  }
  const Array& parameter_names =
      Array::Handle(untag()->positional_parameter_names());
  parameter_names.SetAt(index, value);
#endif
}

◆ SetRegExpData()

void dart::Function::SetRegExpData	(	const RegExp &	regexp,
		intptr_t	string_specialization_cid,
		bool	sticky
	)		const

Definition at line 8550 of file object.cc.

                                                {
  ASSERT(kind() == UntaggedFunction::kIrregexpFunction);
  ASSERT(IsStringClassId(string_specialization_cid));
  ASSERT(data() == Object::null());
  const Array& pair = Array::Handle(Array::New(2, Heap::kOld));
  pair.SetAt(0, regexp);
  pair.SetAt(1, Smi::Handle(Smi::New(StickySpecialization::encode(sticky) |
                                     StringSpecializationCid::encode(
                                         string_specialization_cid))));
  set_data(pair);
}

◆ SetSignature()

void dart::Function::SetSignature ( const FunctionType & value ) const

Definition at line 8604 of file object.cc.

                                                           {
  set_signature(value);
  ASSERT(NumImplicitParameters() == value.num_implicit_parameters());
  if (IsClosureFunction() && value.IsGeneric()) {
    Zone* zone = Thread::Current()->zone();
    const TypeParameters& type_params =
        TypeParameters::Handle(zone, value.type_parameters());
    const TypeArguments& defaults =
        TypeArguments::Handle(zone, type_params.defaults());
    auto mode = defaults.GetInstantiationMode(zone, this);
    set_default_type_arguments_instantiation_mode(mode);
  }
}

◆ SetUsageCounter()

void dart::Function::SetUsageCounter ( intptr_t value ) const

inline

Definition at line 4093 of file object.h.

                                             {
    if (usage_counter() > 0) {
      SetWasExecuted(true);
    }
    set_usage_counter(value);
  }

◆ SetWasExecuted()

void dart::Function::SetWasExecuted ( bool value ) const

inline

Definition at line 4102 of file object.h.

4102{ SetWasExecutedBit(value); }

◆ signature_offset()

static intptr_t dart::Function::signature_offset ( )

inlinestatic

Definition at line 3029 of file object.h.

                                     {
    return OFFSET_OF(UntaggedFunction, signature_);
  }

◆ SourceFingerprint()

int32_t dart::Function::SourceFingerprint ( ) const

Definition at line 11227 of file object.cc.

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

◆ SourceSize()

intptr_t dart::Function::SourceSize ( ) const

Definition at line 11504 of file object.cc.

                                    {
  const TokenPosition& start = token_pos();
  const TokenPosition& end = end_token_pos();
  if (!end.IsReal() || start.IsNoSource() || start.IsClassifying()) {
    // No source information, so just return 0.
    return 0;
  }
  if (start.IsSynthetic()) {
    // Try and approximate the source size using the parent's source size.
    const auto& parent = Function::Handle(parent_function());
    ASSERT(!parent.IsNull());
    const intptr_t parent_size = parent.SourceSize();
    if (parent_size == 0) {
      return parent_size;
    }
    // Parent must have a real ending position.
    return parent_size - (parent.end_token_pos().Pos() - end.Pos());
  }
  return end.Pos() - start.Pos();
}

◆ string_specialization_cid()

intptr_t dart::Function::string_specialization_cid ( ) const

Definition at line 8538 of file object.cc.

                                                   {
  ASSERT(kind() == UntaggedFunction::kIrregexpFunction);
  const Array& pair = Array::Cast(Object::Handle(data()));
  return StringSpecializationCid::decode(Smi::Value(Smi::RawCast(pair.At(1))));
}

◆ SwitchToLazyCompiledUnoptimizedCode()

void dart::Function::SwitchToLazyCompiledUnoptimizedCode ( ) const

Definition at line 8065 of file object.cc.

                                                         {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  if (!HasOptimizedCode()) {
    return;
  }
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  ASSERT(thread->IsDartMutatorThread());
 
  const Code& current_code = Code::Handle(zone, CurrentCode());
  TIR_Print("Disabling optimized code for %s\n", ToCString());
  current_code.DisableDartCode();
 
  const Code& unopt_code = Code::Handle(zone, unoptimized_code());
  if (unopt_code.IsNull()) {
    // Set the lazy compile stub code.
    TIR_Print("Switched to lazy compile stub for %s\n", ToCString());
    SetInstructions(StubCode::LazyCompile());
    return;
  }
 
  TIR_Print("Switched to unoptimized code for %s\n", ToCString());
 
  AttachCode(unopt_code);
  unopt_code.Enable();
#endif
}

◆ SwitchToUnoptimizedCode()

void dart::Function::SwitchToUnoptimizedCode ( ) const

Definition at line 8040 of file object.cc.

                                             {
  ASSERT(HasOptimizedCode());
  ASSERT(!ForceOptimize());
  Thread* thread = Thread::Current();
  DEBUG_ASSERT(
      thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
  Zone* zone = thread->zone();
  // TODO(35224): DEBUG_ASSERT(thread->TopErrorHandlerIsExitFrame());
  const Code& current_code = Code::Handle(zone, CurrentCode());
 
  if (FLAG_trace_deoptimization_verbose) {
    THR_Print("Disabling optimized code: '%s' entry: %#" Px "\n",
              ToFullyQualifiedCString(), current_code.EntryPoint());
  }
  current_code.DisableDartCode();
  const Error& error =
      Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, *this));
  if (!error.IsNull()) {
    Exceptions::PropagateError(error);
  }
  const Code& unopt_code = Code::Handle(zone, unoptimized_code());
  unopt_code.Enable();
  AttachCode(unopt_code);
}

◆ ToFullyQualifiedCString()

const char * dart::Function::ToFullyQualifiedCString ( ) const

Definition at line 9820 of file object.cc.

                                                    {
  char* chars = nullptr;
  ConstructFunctionFullyQualifiedCString(*this, &chars, 0, true,
                                         kQualifiedFunctionLibKindLibUrl);
  return chars;
}

◆ token_pos()

TokenPosition dart::Function::token_pos ( ) const

inline

Definition at line 3426 of file object.h.

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

◆ ToLibNamePrefixedQualifiedCString()

const char * dart::Function::ToLibNamePrefixedQualifiedCString ( ) const

Definition at line 9827 of file object.cc.

                                                              {
  char* chars = nullptr;
  ConstructFunctionFullyQualifiedCString(*this, &chars, 0, true,
                                         kQualifiedFunctionLibKindLibName);
  return chars;
}

◆ ToQualifiedCString()

const char * dart::Function::ToQualifiedCString ( ) const

Definition at line 9834 of file object.cc.

                                               {
  char* chars = nullptr;
  ConstructFunctionFullyQualifiedCString(*this, &chars, 0, false,
                                         kQualifiedFunctionLibKindLibUrl);
  return chars;
}

◆ type_parameters()

TypeParametersPtr dart::Function::type_parameters ( ) const

inline

Definition at line 3109 of file object.h.

                                            {
    return signature()->untag()->type_parameters();
  }

◆ TypeParameterAt()

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

Definition at line 8939 of file object.cc.

                                                                          {
  const FunctionType& sig = FunctionType::Handle(signature());
  return sig.TypeParameterAt(index, nullability);
}

◆ unchecked_entry_point_offset()

static intptr_t dart::Function::unchecked_entry_point_offset ( )

inlinestatic

Definition at line 3195 of file object.h.

                                                 {
    return OFFSET_OF(UntaggedFunction, unchecked_entry_point_);
  }

◆ unoptimized_code()

CodePtr dart::Function::unoptimized_code ( ) const

inline

Definition at line 3165 of file object.h.

                                   {
#if defined(DART_PRECOMPILED_RUNTIME)
    return static_cast<CodePtr>(Object::null());
#else
    return untag()->unoptimized_code();
#endif
  }

◆ UserVisibleName()

StringPtr dart::Function::UserVisibleName ( ) const

Definition at line 11057 of file object.cc.

                                          {
  if (FLAG_show_internal_names) {
    return name();
  }
  return Symbols::New(
      Thread::Current(),
      String::ScrubName(String::Handle(name()),
                        is_extension_member() || is_extension_type_member()));
}

◆ UserVisibleNameCString()

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

Definition at line 11048 of file object.cc.

                                                   {
  if (FLAG_show_internal_names) {
    return String::Handle(name()).ToCString();
  }
  is_extension_type_member();
  return String::ScrubName(String::Handle(name()),
                           is_extension_member() || is_extension_type_member());
}

◆ UserVisibleSignature()

StringPtr dart::Function::UserVisibleSignature ( ) const

Definition at line 10687 of file object.cc.

                                               {
#if defined(DART_PRECOMPILED_RUNTIME)
  if (signature() == FunctionType::null()) {
    return String::null();
  }
#endif
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  const FunctionType& sig = FunctionType::Handle(signature());
  sig.Print(kUserVisibleName, &printer);
  return Symbols::New(thread, printer.buffer());
}

◆ VerifyCallEntryPoint()

ErrorPtr dart::Function::VerifyCallEntryPoint ( ) const

Definition at line 27386 of file object.cc.

                                              {
  if (!FLAG_verify_entry_points) return Error::null();
 
  const Class& cls = Class::Handle(Owner());
  const Library& lib = Library::Handle(cls.library());
  switch (kind()) {
    case UntaggedFunction::kRegularFunction:
    case UntaggedFunction::kSetterFunction:
    case UntaggedFunction::kConstructor:
      return dart::VerifyEntryPoint(lib, *this, *this,
                                    {EntryPointPragma::kCallOnly});
      break;
    case UntaggedFunction::kGetterFunction:
      return dart::VerifyEntryPoint(
          lib, *this, *this,
          {EntryPointPragma::kCallOnly, EntryPointPragma::kGetterOnly});
      break;
    case UntaggedFunction::kImplicitGetter:
      return dart::VerifyEntryPoint(lib, *this, Field::Handle(accessor_field()),
                                    {EntryPointPragma::kGetterOnly});
      break;
    case UntaggedFunction::kImplicitSetter:
      return dart::VerifyEntryPoint(lib, *this, Field::Handle(accessor_field()),
                                    {EntryPointPragma::kSetterOnly});
    case UntaggedFunction::kMethodExtractor:
      return Function::Handle(extracted_method_closure())
          .VerifyClosurizedEntryPoint();
      break;
    default:
      return dart::VerifyEntryPoint(lib, *this, Object::Handle(), {});
      break;
  }
}

◆ VerifyClosurizedEntryPoint()

ErrorPtr dart::Function::VerifyClosurizedEntryPoint ( ) const

Definition at line 27420 of file object.cc.

                                                    {
  if (!FLAG_verify_entry_points) return Error::null();
 
  const Class& cls = Class::Handle(Owner());
  const Library& lib = Library::Handle(cls.library());
  switch (kind()) {
    case UntaggedFunction::kRegularFunction:
      return dart::VerifyEntryPoint(lib, *this, *this,
                                    {EntryPointPragma::kGetterOnly});
    case UntaggedFunction::kImplicitClosureFunction: {
      const Function& parent = Function::Handle(parent_function());
      return dart::VerifyEntryPoint(lib, parent, parent,
                                    {EntryPointPragma::kGetterOnly});
    }
    default:
      UNREACHABLE();
  }
}

◆ WasExecuted()

bool dart::Function::WasExecuted ( ) const

inline

Definition at line 4100 of file object.h.

4100{ return (usage_counter() > 0) || WasExecutedBit(); }

Friends And Related Symbol Documentation

◆ Class

friend class Class

friend

Definition at line 4281 of file object.h.

◆ ClassFinalizer

friend class ClassFinalizer

friend

Definition at line 4286 of file object.h.

◆ Parser

friend class Parser

friend

Definition at line 4282 of file object.h.

◆ Precompiler

friend class Precompiler

friend

Definition at line 4288 of file object.h.

◆ ProgramVisitor

friend class ProgramVisitor

friend

Definition at line 4289 of file object.h.

◆ Type

friend class Type

friend

Definition at line 4287 of file object.h.

◆ UntaggedFunction

friend class UntaggedFunction

friend

Definition at line 4285 of file object.h.

Member Data Documentation

◆ kMaxInstructionCount

constexpr intptr_t dart::Function::kMaxInstructionCount = (1 << 16) - 1

staticconstexpr

Definition at line 3550 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_service.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ KindTagBits

◆ StateBits

Member Function Documentation

◆ accessor_field()

◆ AddFunctionServiceId()

◆ AreValidArgumentCounts()

◆ AreValidArguments() [1/2]

◆ AreValidArguments() [2/2]

◆ AssignFfiCallbackId()

◆ AttachCode()

◆ awaiter_link()

◆ CanBeInlined()

◆ CheckSourceFingerprint()

◆ ClearCode()

◆ ClearCodeSafe()

◆ ClearICDataArray()

◆ code_offset()

◆ COMPILE_ASSERT() [1/2]

◆ COMPILE_ASSERT() [2/2]

◆ context_scope()

◆ CreateDynamicInvocationForwarder()

◆ CreateDynamicInvocationForwarderName()

◆ CreateMethodExtractor()

◆ CreateNameArray()

◆ CurrentCode()

◆ CurrentCodeOf()

◆ data_offset()

◆ default_type_arguments_instantiation_mode()

◆ DefaultTypeArguments()

◆ DemangleDynamicInvocationForwarderName()

◆ DictionaryName()

◆ DoArgumentTypesMatch() [1/3]

◆ DoArgumentTypesMatch() [2/3]

◆ DoArgumentTypesMatch() [3/3]

◆ DropUncompiledImplicitClosureFunction()

◆ end_token_pos()

◆ EnsureHasCode()

◆ EnsureHasCompiledUnoptimizedCode()

◆ entry_point()

◆ entry_point_offset()

◆ EntryPointOf()

◆ extracted_method_closure()

◆ FfiCallbackExceptionalReturn()

◆ FfiCallbackId()

◆ FfiCallbackTarget()

◆ FfiCSignature()

◆ FfiCSignatureContainsHandles()

◆ FfiCSignatureReturnsStruct()

◆ FfiIsLeaf()

◆ FindICData()

◆ ForceOptimize()

◆ ForwardingTarget()

◆ GetCoverageArray()

◆ GetDynamicInvocationForwarder()

◆ GetFfiCallbackKind()

◆ GetFfiCallClosurePragmaValue()

◆ GetMethodExtractor()

◆ GetNativeAnnotation()

◆ GetOutermostFunction()

◆ GetSource()

◆ has_unboxed_double_return()

◆ has_unboxed_integer_return()

◆ has_unboxed_record_return()

◆ has_unboxed_return()

◆ HasAwaiterLink()

◆ HasBreakpoint()

◆ HasCode() [1/2]

◆ HasCode() [2/2]

◆ HasDynamicCallers()

◆ HasGenericParent()

◆ Hash()