#include <object.h>

Inheritance diagram for dart::FunctionType:

Public Types
using	PackedNumParentTypeArguments = UntaggedFunctionType::PackedNumParentTypeArguments

using	PackedNumTypeParameters = UntaggedFunctionType::PackedNumTypeParameters

using	PackedHasNamedOptionalParameters = UntaggedFunctionType::PackedHasNamedOptionalParameters

using	PackedNumImplicitParameters = UntaggedFunctionType::PackedNumImplicitParameters

using	PackedNumFixedParameters = UntaggedFunctionType::PackedNumFixedParameters

using	PackedNumOptionalParameters = UntaggedFunctionType::PackedNumOptionalParameters

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
virtual bool	HasTypeClass () const

FunctionTypePtr	ToNullability (Nullability value, Heap::Space space) const

virtual classid_t	type_class_id () const

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

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

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

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

virtual AbstractTypePtr	Canonicalize (Thread *thread) const

virtual void	EnumerateURIs (URIs *uris) const

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

virtual uword	ComputeHash () const

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

intptr_t	NumParentTypeArguments () const

void	SetNumParentTypeArguments (intptr_t value) const

intptr_t	NumTypeParameters () const

intptr_t	NumTypeArguments () const

intptr_t	num_implicit_parameters () const

void	set_num_implicit_parameters (intptr_t value) const

intptr_t	num_fixed_parameters () const

void	set_num_fixed_parameters (intptr_t value) const

bool	HasOptionalParameters () const

bool	HasOptionalNamedParameters () const

bool	HasRequiredNamedParameters () const

bool	HasOptionalPositionalParameters () const

intptr_t	NumOptionalParameters () const

void	SetNumOptionalParameters (intptr_t num_optional_parameters, bool are_optional_positional) const

intptr_t	NumOptionalPositionalParameters () const

intptr_t	NumOptionalNamedParameters () const

intptr_t	NumParameters () const

uint32_t	packed_parameter_counts () const

void	set_packed_parameter_counts (uint32_t packed_parameter_counts) const

uint16_t	packed_type_parameter_counts () const

void	set_packed_type_parameter_counts (uint16_t packed_parameter_counts) const

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

AbstractTypePtr	result_type () const

void	set_result_type (const AbstractType &value) const

AbstractTypePtr	ParameterTypeAt (intptr_t index) const

void	SetParameterTypeAt (intptr_t index, const AbstractType &value) const

ArrayPtr	parameter_types () const

void	set_parameter_types (const Array &value) const

ArrayPtr	named_parameter_names () const

void	set_named_parameter_names (const Array &value) const

StringPtr	ParameterNameAt (intptr_t index) const

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

bool	IsRequiredAt (intptr_t index) const

void	SetIsRequiredAt (intptr_t index) const

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

void	FinalizeNameArray () const

TypeParametersPtr	type_parameters () const

void	SetTypeParameters (const TypeParameters &value) const

bool	HasSameTypeParametersAndBounds (const FunctionType &other, TypeEquality kind, FunctionTypeMapping *function_type_equivalence=nullptr) const

bool	IsGeneric () const

bool	HasGenericParent () const

bool	IsContravariantParameter (intptr_t parameter_position, const FunctionType &other, intptr_t other_parameter_position, Heap::Space space, FunctionTypeMapping *function_type_equivalence) const

intptr_t	GetRequiredFlagIndex (intptr_t index, intptr_t *flag_mask) const

void	Print (NameVisibility name_visibility, BaseTextBuffer *printer) const

void	PrintParameters (Thread thread, Zone zone, NameVisibility name_visibility, BaseTextBuffer *printer) const

StringPtr	ToUserVisibleString () const

const char *	ToUserVisibleCString () const

bool	ContainsHandles () const

Public Member Functions inherited from dart::AbstractType
bool	IsFinalized () const

void	SetIsFinalized () const

Nullability	nullability () const

bool	IsNullable () const

bool	IsNonNullable () const

bool	IsLegacy () const

bool	IsStrictlyNonNullable () const

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

virtual AbstractTypePtr	NormalizeFutureOrType (Heap::Space space) const

virtual ClassPtr	type_class () const

virtual TypeArgumentsPtr	arguments () const

virtual bool	CanonicalizeEquals (const Instance &other) const

virtual uint32_t	CanonicalizeHash () const

virtual bool	Equals (const Instance &other) const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

virtual const char *	NullabilitySuffix (NameVisibility name_visibility) const

StringPtr	Name () const

const char *	NameCString () const

StringPtr	UserVisibleName () const

const char *	UserVisibleNameCString () const

StringPtr	ScrubbedName () const

const char *	ScrubbedNameCString () const

uword	Hash () const

StringPtr	ClassName () const

bool	IsDynamicType () const

bool	IsVoidType () const

bool	IsNullType () const

bool	IsNeverType () const

bool	IsSentinelType () const

bool	IsObjectType () const

bool	IsNullableObjectType () const

bool	IsTopTypeForSubtyping () const

bool	IsTopTypeForInstanceOf () const

bool	IsBoolType () const

bool	IsIntType () const

bool	IsIntegerImplementationType () const

bool	IsDoubleType () const

bool	IsFloat32x4Type () const

bool	IsFloat64x2Type () const

bool	IsInt32x4Type () const

bool	IsNumberType () const

bool	IsSmiType () const

bool	IsMintType () const

bool	IsStringType () const

bool	IsDartFunctionType () const

bool	IsDartClosureType () const

bool	IsDartRecordType () const

bool	IsFfiPointerType () const

bool	IsFutureOrType () const

AbstractTypePtr	UnwrapFutureOr () const

bool	IsCatchAllType () const

bool	IsTypeClassAllowedBySpawnUri () const

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

uword	type_test_stub_entry_point () const

CodePtr	type_test_stub () const

void	SetTypeTestingStub (const Code &stub) const

void	InitializeTypeTestingStubNonAtomic (const Code &stub) const

void	UpdateTypeTestingStubEntryPoint () const

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

bool	IsIdenticalTo (const Instance &other) const

intptr_t	SizeFromClass () const

InstancePtr	Canonicalize (Thread *thread) const

virtual void	CanonicalizeFieldsLocked (Thread *thread) const

InstancePtr	CopyShallowToOldSpace (Thread *thread) const

ObjectPtr	GetField (const Field &field) const

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

AbstractTypePtr	GetType (Heap::Space space) const

virtual TypeArgumentsPtr	GetTypeArguments () const

virtual void	SetTypeArguments (const TypeArguments &value) const

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

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

bool	IsValidNativeIndex (int index) const

intptr_t *	NativeFieldsDataAddr () const

intptr_t	GetNativeField (int index) const

void	GetNativeFields (uint16_t num_fields, intptr_t *field_values) const

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

uint16_t	NumNativeFields () const

void	SetNativeField (int index, intptr_t value) const

bool	IsCallable (Function *function) const

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

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

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

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

virtual ObjectPtr	HashCode () const

IntegerPtr	IdentityHashCode (Thread *thread) const

virtual bool	IsPointer () const

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

ObjectPtr	ptr () const

void	operator= (ObjectPtr value)

bool	IsCanonical () const

void	SetCanonical () const

void	ClearCanonical () const

bool	IsImmutable () const

void	SetImmutable () const

void	ClearImmutable () const

intptr_t	GetClassId () const

ClassPtr	clazz () const

	CLASS_LIST_FOR_HANDLES (DEFINE_CLASS_TESTER)

bool	IsNull () const

virtual const char *	ToCString () const

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

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

void	PrintImplementationFields (JSONStream *stream) const

virtual void	PrintImplementationFieldsImpl (const JSONArray &jsarr_fields) const

virtual const char *	JSONType () const

virtual StringPtr	DictionaryName () const

bool	IsNew () const

bool	IsOld () const

bool	InVMIsolateHeap () const

void	Print () const

Static Public Member Functions
static intptr_t	NumParentTypeArgumentsOf (FunctionTypePtr ptr)

static intptr_t	NumTypeParametersOf (FunctionTypePtr ptr)

static intptr_t	NumTypeArgumentsOf (FunctionTypePtr ptr)

static intptr_t	NumFixedParametersOf (FunctionTypePtr ptr)

static bool	HasOptionalParameters (FunctionTypePtr ptr)

static bool	HasOptionalNamedParameters (FunctionTypePtr ptr)

static bool	HasOptionalPositionalParameters (FunctionTypePtr ptr)

static intptr_t	NumOptionalParametersOf (FunctionTypePtr ptr)

static intptr_t	NumOptionalPositionalParametersOf (FunctionTypePtr ptr)

static intptr_t	NumOptionalNamedParametersOf (FunctionTypePtr ptr)

static intptr_t	NumParametersOf (FunctionTypePtr ptr)

static intptr_t	packed_parameter_counts_offset ()

static intptr_t	packed_type_parameter_counts_offset ()

static intptr_t	parameter_types_offset ()

static intptr_t	named_parameter_names_offset ()

static intptr_t	NameArrayLengthIncludingFlags (intptr_t num_parameters)

static intptr_t	type_parameters_offset ()

static bool	IsGeneric (FunctionTypePtr ptr)

static intptr_t	InstanceSize ()

static FunctionTypePtr	New (intptr_t num_parent_type_arguments=0, Nullability nullability=Nullability::kLegacy, Heap::Space space=Heap::kOld)

static FunctionTypePtr	Clone (const FunctionType &orig, Heap::Space space)

Static Public Member Functions inherited from dart::AbstractType
static intptr_t	flags_offset ()

static intptr_t	hash_offset ()

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

static StringPtr	PrintURIs (URIs *uris)

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

static intptr_t	type_test_stub_entry_point_offset ()

static intptr_t	InstanceSize ()

static intptr_t	NextFieldOffset ()

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

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

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

static intptr_t	UnroundedSize ()

static intptr_t	InstanceSize ()

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

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

static intptr_t	DataOffsetFor (intptr_t cid)

static intptr_t	ElementSizeFor (intptr_t cid)

static intptr_t	NextFieldOffset ()

static intptr_t	NativeFieldsOffset ()

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

static constexpr bool	ContainsCompressedPointers ()

static intptr_t	tags_offset ()

static Object &	Handle ()

static Object &	Handle (Zone *zone)

static Object &	Handle (ObjectPtr ptr)

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

static Object &	ZoneHandle ()

static Object &	ZoneHandle (Zone *zone)

static Object &	ZoneHandle (ObjectPtr ptr)

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

static Object *	ReadOnlyHandle ()

static ObjectPtr	null ()

static void	set_vm_isolate_snapshot_object_table (const Array &table)

static ClassPtr	class_class ()

static ClassPtr	dynamic_class ()

static ClassPtr	void_class ()

static ClassPtr	type_parameters_class ()

static ClassPtr	type_arguments_class ()

static ClassPtr	patch_class_class ()

static ClassPtr	function_class ()

static ClassPtr	closure_data_class ()

static ClassPtr	ffi_trampoline_data_class ()

static ClassPtr	field_class ()

static ClassPtr	script_class ()

static ClassPtr	library_class ()

static ClassPtr	namespace_class ()

static ClassPtr	kernel_program_info_class ()

static ClassPtr	code_class ()

static ClassPtr	instructions_class ()

static ClassPtr	instructions_section_class ()

static ClassPtr	instructions_table_class ()

static ClassPtr	object_pool_class ()

static ClassPtr	pc_descriptors_class ()

static ClassPtr	code_source_map_class ()

static ClassPtr	compressed_stackmaps_class ()

static ClassPtr	var_descriptors_class ()

static ClassPtr	exception_handlers_class ()

static ClassPtr	context_class ()

static ClassPtr	context_scope_class ()

static ClassPtr	sentinel_class ()

static ClassPtr	api_error_class ()

static ClassPtr	language_error_class ()

static ClassPtr	unhandled_exception_class ()

static ClassPtr	unwind_error_class ()

static ClassPtr	singletargetcache_class ()

static ClassPtr	unlinkedcall_class ()

static ClassPtr	monomorphicsmiablecall_class ()

static ClassPtr	icdata_class ()

static ClassPtr	megamorphic_cache_class ()

static ClassPtr	subtypetestcache_class ()

static ClassPtr	loadingunit_class ()

static ClassPtr	weak_serialization_reference_class ()

static ClassPtr	weak_array_class ()

static void	InitNullAndBool (IsolateGroup *isolate_group)

static void	Init (IsolateGroup *isolate_group)

static void	InitVtables ()

static void	FinishInit (IsolateGroup *isolate_group)

static void	FinalizeVMIsolate (IsolateGroup *isolate_group)

static void	FinalizeReadOnlyObject (ObjectPtr object)

static void	Cleanup ()

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

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

static intptr_t	InstanceSize ()

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

static void	VerifyBuiltinVtables ()

static bool	ShouldHaveImmutabilityBitSet (classid_t class_id)

Friends
class	Class

class	Function

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

static const ClassId	kClassId = kObjectCid

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

void	SetHash (intptr_t value) const

UntaggedAbstractType::TypeState	type_state () const

void	set_flags (uint32_t value) const

void	set_type_state (UntaggedAbstractType::TypeState value) const

void	set_nullability (Nullability value) const

	HEAP_OBJECT_IMPLEMENTATION (AbstractType, Instance)

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

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

uword	raw_value () const

void	setPtr (ObjectPtr value, intptr_t default_cid)

void	CheckHandle () const

cpp_vtable	vtable () const

void	set_vtable (cpp_vtable value)

bool	Contains (uword addr) const

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

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

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

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

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

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

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

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

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

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

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

	CLASS_LIST (STORE_NON_POINTER_ILLEGAL_TYPE)

void	UnimplementedMethod () const

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

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

Member Typedef Documentation

◆ PackedHasNamedOptionalParameters

using dart::FunctionType::PackedHasNamedOptionalParameters = UntaggedFunctionType::PackedHasNamedOptionalParameters

Definition at line 9499 of file object.h.

◆ PackedNumFixedParameters

using dart::FunctionType::PackedNumFixedParameters = UntaggedFunctionType::PackedNumFixedParameters

Definition at line 9503 of file object.h.

◆ PackedNumImplicitParameters

using dart::FunctionType::PackedNumImplicitParameters = UntaggedFunctionType::PackedNumImplicitParameters

Definition at line 9501 of file object.h.

◆ PackedNumOptionalParameters

using dart::FunctionType::PackedNumOptionalParameters = UntaggedFunctionType::PackedNumOptionalParameters

Definition at line 9505 of file object.h.

◆ PackedNumParentTypeArguments

using dart::FunctionType::PackedNumParentTypeArguments = UntaggedFunctionType::PackedNumParentTypeArguments

Definition at line 9496 of file object.h.

◆ PackedNumTypeParameters

using dart::FunctionType::PackedNumTypeParameters = UntaggedFunctionType::PackedNumTypeParameters

Definition at line 9498 of file object.h.

Member Function Documentation

◆ Canonicalize()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 22539 of file object.cc.

                                                               {
  ASSERT(IsFinalized());
  Zone* zone = thread->zone();
  if (IsCanonical()) {
#ifdef DEBUG
    // Verify that all fields are allocated in old space and are canonical.
    if (IsGeneric()) {
      const TypeParameters& type_params =
          TypeParameters::Handle(zone, type_parameters());
      ASSERT(type_params.IsOld());
      TypeArguments& type_args = TypeArguments::Handle(zone);
      type_args = type_params.bounds();
      ASSERT(type_args.IsOld());
      ASSERT(type_args.IsCanonical());
      type_args = type_params.defaults();
      ASSERT(type_args.IsOld());
      ASSERT(type_args.IsCanonical());
    }
    AbstractType& type = AbstractType::Handle(zone);
    type = result_type();
    ASSERT(type.IsOld());
    ASSERT(type.IsCanonical());
    ASSERT(Array::Handle(zone, parameter_types()).IsOld());
    ASSERT(Array::Handle(zone, named_parameter_names()).IsOld());
    const intptr_t num_params = NumParameters();
    for (intptr_t i = 0; i < num_params; i++) {
      type = ParameterTypeAt(i);
      ASSERT(type.IsOld());
      ASSERT(type.IsCanonical());
    }
#endif
    return ptr();
  }
  auto isolate_group = thread->isolate_group();
  ObjectStore* object_store = isolate_group->object_store();
  FunctionType& sig = FunctionType::Handle(zone);
  {
    SafepointMutexLocker ml(isolate_group->type_canonicalization_mutex());
    CanonicalFunctionTypeSet table(zone,
                                   object_store->canonical_function_types());
    sig ^= table.GetOrNull(CanonicalFunctionTypeKey(*this));
    ASSERT(object_store->canonical_function_types() == table.Release().ptr());
  }
  if (sig.IsNull()) {
    // The function type was not found in the table. It is not canonical yet.
    // Canonicalize its type parameters and types.
 
    // Clone this function type to the old heap and update
    // owners of type parameters.
    FunctionType& new_sig = FunctionType::Handle(zone);
    if (this->IsNew()) {
      new_sig ^= FunctionType::Clone(*this, Heap::kOld);
    } else {
      new_sig ^= this->ptr();
    }
    ASSERT(new_sig.IsOld());
 
    if (new_sig.IsGeneric()) {
      const TypeParameters& type_params =
          TypeParameters::Handle(zone, new_sig.type_parameters());
      ASSERT(type_params.IsOld());
      TypeArguments& type_args = TypeArguments::Handle(zone);
      type_args = type_params.bounds();
      if (!type_args.IsCanonical()) {
        type_args = type_args.Canonicalize(thread);
        type_params.set_bounds(type_args);
      }
      type_args = type_params.defaults();
      if (!type_args.IsCanonical()) {
        type_args = type_args.Canonicalize(thread);
        type_params.set_defaults(type_args);
      }
    }
    AbstractType& type = AbstractType::Handle(zone);
    type = new_sig.result_type();
    if (!type.IsCanonical()) {
      type = type.Canonicalize(thread);
      new_sig.set_result_type(type);
    }
    ASSERT(Array::Handle(zone, new_sig.parameter_types()).IsOld());
    ASSERT(Array::Handle(zone, new_sig.named_parameter_names()).IsOld());
    const intptr_t num_params = new_sig.NumParameters();
    for (intptr_t i = 0; i < num_params; i++) {
      type = new_sig.ParameterTypeAt(i);
      if (!type.IsCanonical()) {
        type = type.Canonicalize(thread);
        new_sig.SetParameterTypeAt(i, type);
      }
    }
    // Check to see if the function type got added to canonical table
    // during canonicalization of its signature types.
    SafepointMutexLocker ml(isolate_group->type_canonicalization_mutex());
    CanonicalFunctionTypeSet table(zone,
                                   object_store->canonical_function_types());
    sig ^= table.GetOrNull(CanonicalFunctionTypeKey(new_sig));
    if (sig.IsNull()) {
      // Add this function type into the canonical table of function types.
      sig = new_sig.ptr();
      ASSERT(sig.IsOld());
      sig.SetCanonical();  // Mark object as being canonical.
      bool present = table.Insert(sig);
      ASSERT(!present);
    }
    object_store->set_canonical_function_types(table.Release());
  }
  return sig.ptr();
}

◆ Clone()

FunctionTypePtr dart::FunctionType::Clone	(	const FunctionType &	orig,
		Heap::Space	space
	)

static

Definition at line 11701 of file object.cc.

                                                     {
  if (orig.IsGeneric()) {
    // Need a deep clone in order to update owners of type parameters.
    return FunctionType::RawCast(
        orig.UpdateFunctionTypes(0, kAllFree, space, nullptr));
  } else {
    return FunctionType::RawCast(Object::Clone(orig, space));
  }
}

◆ ComputeHash()

uword dart::FunctionType::ComputeHash ( ) const

virtual

Reimplemented from dart::AbstractType.

Definition at line 22421 of file object.cc.

                                      {
  ASSERT(IsFinalized());
  uint32_t result =
      CombineHashes(packed_parameter_counts(), packed_type_parameter_counts());
  // A legacy type should have the same hash as its non-nullable version to be
  // consistent with the definition of type equality in Dart code.
  Nullability type_nullability = nullability();
  if (type_nullability == Nullability::kLegacy) {
    type_nullability = Nullability::kNonNullable;
  }
  result = CombineHashes(result, static_cast<uint32_t>(type_nullability));
  AbstractType& type = AbstractType::Handle();
  const intptr_t num_type_params = NumTypeParameters();
  if (num_type_params > 0) {
    const TypeParameters& type_params =
        TypeParameters::Handle(type_parameters());
    const TypeArguments& bounds = TypeArguments::Handle(type_params.bounds());
    result = CombineHashes(result, bounds.Hash());
    // Since the default arguments are ignored when comparing two generic
    // function types for type equality, the hash does not depend on them.
  }
  type = result_type();
  result = CombineHashes(result, type.Hash());
  const intptr_t num_params = NumParameters();
  for (intptr_t i = 0; i < num_params; i++) {
    type = ParameterTypeAt(i);
    result = CombineHashes(result, type.Hash());
  }
  if (HasOptionalNamedParameters()) {
    String& param_name = String::Handle();
    for (intptr_t i = num_fixed_parameters(); i < num_params; i++) {
      param_name = ParameterNameAt(i);
      result = CombineHashes(result, param_name.Hash());
    }
    // Required flag is not hashed, see comment above about legacy type.
  }
  result = FinalizeHash(result, kHashBits);
  SetHash(result);
  return result;
}

◆ ContainsHandles()

bool dart::FunctionType::ContainsHandles ( ) const

Definition at line 8350 of file object.cc.

                                         {
  const intptr_t num_params = num_fixed_parameters();
  for (intptr_t i = 0; i < num_params; i++) {
    const bool is_handle =
        AbstractType::Handle(ParameterTypeAt(i)).type_class_id() ==
        kFfiHandleCid;
    if (is_handle) {
      return true;
    }
  }
  return AbstractType::Handle(result_type()).type_class_id() == kFfiHandleCid;
}

◆ CreateNameArrayIncludingFlags()

void dart::FunctionType::CreateNameArrayIncludingFlags ( Heap::Space space = Heap::kOld ) const

Definition at line 8750 of file object.cc.

                                                                      {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  const intptr_t num_named_parameters = NumOptionalNamedParameters();
  if (num_named_parameters == 0) {
    return set_named_parameter_names(Object::empty_array());
  }
  // Currently, we only store flags for named parameters.
  const intptr_t last_index = (num_named_parameters - 1) /
                              compiler::target::kNumParameterFlagsPerElement;
  const intptr_t num_flag_slots = last_index + 1;
  intptr_t num_total_slots = num_named_parameters + num_flag_slots;
  auto& array = Array::Handle(Array::New(num_total_slots, space));
  // Set flag slots to Smi 0 before handing off.
  auto& empty_flags_smi = Smi::Handle(Smi::New(0));
  for (intptr_t i = num_named_parameters; i < num_total_slots; i++) {
    array.SetAt(i, empty_flags_smi);
  }
  set_named_parameter_names(array);
#endif
}

◆ EnumerateURIs()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 22647 of file object.cc.

                                                 {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  AbstractType& type = AbstractType::Handle(zone);
  const intptr_t num_params = NumParameters();
  for (intptr_t i = 0; i < num_params; i++) {
    type = ParameterTypeAt(i);
    type.EnumerateURIs(uris);
  }
  // Handle result type last, since it appears last in the user visible name.
  type = result_type();
  type.EnumerateURIs(uris);
}

◆ FinalizeNameArray()

void dart::FunctionType::FinalizeNameArray ( ) const

Definition at line 8844 of file object.cc.

                                           {
#if defined(DART_PRECOMPILER_RUNTIME)
  UNREACHABLE();
#else
  const intptr_t num_named_parameters = NumOptionalNamedParameters();
  if (num_named_parameters == 0) {
    ASSERT(untag()->named_parameter_names() == Object::empty_array().ptr());
    return;
  }
  const Array& parameter_names =
      Array::Handle(untag()->named_parameter_names());
  // Truncate the parameter names array to remove unused flags from the end.
  intptr_t last_used = parameter_names.Length() - 1;
  for (; last_used >= num_named_parameters; --last_used) {
    if (Smi::Value(Smi::RawCast(parameter_names.At(last_used))) != 0) {
      break;
    }
  }
  parameter_names.Truncate(last_used + 1);
#endif
}

◆ GetRequiredFlagIndex()

intptr_t dart::FunctionType::GetRequiredFlagIndex	(	intptr_t	index,
		intptr_t *	flag_mask
	)		const

Definition at line 8773 of file object.cc.

                                                                       {
  // If these calculations change, also change
  // FlowGraphBuilder::BuildClosureCallHasRequiredNamedArgumentsCheck.
  ASSERT(HasOptionalNamedParameters());
  ASSERT(flag_mask != nullptr);
  ASSERT(index >= num_fixed_parameters());
  index -= num_fixed_parameters();
  *flag_mask = (1 << compiler::target::kRequiredNamedParameterFlag)
               << ((static_cast<uintptr_t>(index) %
                    compiler::target::kNumParameterFlagsPerElement) *
                   compiler::target::kNumParameterFlags);
  return NumOptionalNamedParameters() +
         index / compiler::target::kNumParameterFlagsPerElement;
}

◆ HasGenericParent()

bool dart::FunctionType::HasGenericParent ( ) const

inline

Definition at line 9730 of file object.h.

9730{ return NumParentTypeArguments() > 0; }

dart::FunctionType::NumParentTypeArguments

intptr_t NumParentTypeArguments() const

Definition object.h:9550

◆ HasOptionalNamedParameters() [1/2]

bool dart::FunctionType::HasOptionalNamedParameters ( ) const

inline

Definition at line 9589 of file object.h.

                                          {
    return HasOptionalNamedParameters(ptr());
  }

◆ HasOptionalNamedParameters() [2/2]

static bool dart::FunctionType::HasOptionalNamedParameters ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9585 of file object.h.

                                                              {
    return ptr->untag()
        ->packed_parameter_counts_.Read<PackedHasNamedOptionalParameters>();
  }

◆ HasOptionalParameters() [1/2]

bool dart::FunctionType::HasOptionalParameters ( ) const

inline

Definition at line 9583 of file object.h.

9583{ return HasOptionalParameters(ptr()); }

dart::FunctionType::HasOptionalParameters

bool HasOptionalParameters() const

Definition object.h:9583

◆ HasOptionalParameters() [2/2]

static bool dart::FunctionType::HasOptionalParameters ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9578 of file object.h.

                                                         {
    return ptr->untag()
               ->packed_parameter_counts_.Read<PackedNumOptionalParameters>() >
           0;
  }

◆ HasOptionalPositionalParameters() [1/2]

bool dart::FunctionType::HasOptionalPositionalParameters ( ) const

inline

Definition at line 9597 of file object.h.

                                               {
    return HasOptionalPositionalParameters(ptr());
  }

◆ HasOptionalPositionalParameters() [2/2]

static bool dart::FunctionType::HasOptionalPositionalParameters ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9594 of file object.h.

                                                                   {
    return !HasOptionalNamedParameters(ptr) && HasOptionalParameters(ptr);
  }

◆ HasRequiredNamedParameters()

bool dart::FunctionType::HasRequiredNamedParameters ( ) const

Definition at line 8866 of file object.cc.

                                                    {
  const intptr_t num_named_params = NumOptionalNamedParameters();
  if (num_named_params == 0) return false;
  // Check for flag slots in the named parameter names array.
  const auto& parameter_names = Array::Handle(named_parameter_names());
  ASSERT(!parameter_names.IsNull());
  return parameter_names.Length() > num_named_params;
}

◆ HasSameTypeParametersAndBounds()

bool dart::FunctionType::HasSameTypeParametersAndBounds	(	const FunctionType &	other,
		TypeEquality	kind,
		FunctionTypeMapping *	function_type_equivalence = `nullptr`
	)		const

Definition at line 10059 of file object.cc.

                                                          {
  Zone* const zone = Thread::Current()->zone();
  TRACE_TYPE_CHECKS_VERBOSE(
      "  FunctionType::HasSameTypeParametersAndBounds(%s, %s)\n", ToCString(),
      other.ToCString());
 
  const intptr_t num_type_params = NumTypeParameters();
  if (num_type_params != other.NumTypeParameters()) {
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (number of type parameters)\n");
    return false;
  }
  if (num_type_params > 0) {
    const TypeParameters& type_params =
        TypeParameters::Handle(zone, type_parameters());
    ASSERT(!type_params.IsNull());
    const TypeParameters& other_type_params =
        TypeParameters::Handle(zone, other.type_parameters());
    ASSERT(!other_type_params.IsNull());
    if (kind == TypeEquality::kInSubtypeTest) {
      if (!type_params.AllDynamicBounds() ||
          !other_type_params.AllDynamicBounds()) {
        AbstractType& bound = AbstractType::Handle(zone);
        AbstractType& other_bound = AbstractType::Handle(zone);
        for (intptr_t i = 0; i < num_type_params; i++) {
          bound = type_params.BoundAt(i);
          other_bound = other_type_params.BoundAt(i);
          // Bounds that are mutual subtypes are considered equal.
          if (!bound.IsSubtypeOf(other_bound, Heap::kOld,
                                 function_type_equivalence) ||
              !other_bound.IsSubtypeOf(bound, Heap::kOld,
                                       function_type_equivalence)) {
            TRACE_TYPE_CHECKS_VERBOSE(
                "   - result: false (bounds are not mutual subtypes)\n");
            return false;
          }
        }
      }
    } else {
      if (NumParentTypeArguments() != other.NumParentTypeArguments()) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: false (mismatch in number of type arguments)\n");
        return false;
      }
      const TypeArguments& bounds =
          TypeArguments::Handle(zone, type_params.bounds());
      const TypeArguments& other_bounds =
          TypeArguments::Handle(zone, other_type_params.bounds());
      if (!bounds.IsEquivalent(other_bounds, kind, function_type_equivalence)) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: false (bounds are not equivalent)\n");
        return false;
      }
      if (kind == TypeEquality::kCanonical) {
        // Compare default arguments.
        const TypeArguments& defaults =
            TypeArguments::Handle(zone, type_params.defaults());
        const TypeArguments& other_defaults =
            TypeArguments::Handle(zone, other_type_params.defaults());
        if (defaults.IsNull()) {
          if (!other_defaults.IsNull()) {
            TRACE_TYPE_CHECKS_VERBOSE(
                "   - result: false (mismatch in defaults)\n");
            return false;
          }
        } else if (!defaults.IsEquivalent(other_defaults, kind,
                                          function_type_equivalence)) {
          TRACE_TYPE_CHECKS_VERBOSE(
              "   - result: false (default types are not equivalent)\n");
          return false;
        }
      }
    }
    if (kind != TypeEquality::kInSubtypeTest) {
      // Compare flags (IsGenericCovariantImpl).
      if (!Array::Equals(type_params.flags(), other_type_params.flags())) {
        TRACE_TYPE_CHECKS_VERBOSE("   - result: false (flags are not equal)\n");
        return false;
      }
    }
  }
  TRACE_TYPE_CHECKS_VERBOSE("   - result: true\n");
  return true;
}

◆ HasTypeClass()

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

inlinevirtual

Reimplemented from dart::AbstractType.

Definition at line 9508 of file object.h.

9508{ return false; }

◆ InstanceSize()

static intptr_t dart::FunctionType::InstanceSize ( )

inlinestatic

Definition at line 9756 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedFunctionType));
  }

◆ InstantiateFrom()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 9841 of file object.cc.

                                                    {
  ASSERT(IsFinalized());
  Zone* zone = Thread::Current()->zone();
  const intptr_t num_parent_type_args = NumParentTypeArguments();
  bool delete_type_parameters = false;
  if (num_free_fun_type_params == kCurrentAndEnclosingFree) {
    // See the comment on kCurrentAndEnclosingFree to understand why we don't
    // adjust 'num_free_fun_type_params' downward in this case.
    num_free_fun_type_params = kAllFree;
    delete_type_parameters = true;
  } else {
    ASSERT(!IsInstantiated(kAny, num_free_fun_type_params));
    // We only consider the function type parameters declared by the parents
    // of this signature function as free.
    if (num_parent_type_args < num_free_fun_type_params) {
      num_free_fun_type_params = num_parent_type_args;
    }
  }
 
  // The number of parent type parameters that remain uninstantiated.
  const intptr_t remaining_parent_type_params =
      num_free_fun_type_params < num_parent_type_args
          ? num_parent_type_args - num_free_fun_type_params
          : 0;
 
  // Adjust number of parent type arguments for all nested substituted types.
  num_parent_type_args_adjustment =
      remaining_parent_type_params +
      (delete_type_parameters ? 0 : NumTypeParameters());
 
  FunctionType& sig = FunctionType::Handle(
      FunctionType::New(remaining_parent_type_params, nullability(), space));
  AbstractType& type = AbstractType::Handle(zone);
 
  FunctionTypeMapping scope(zone, &function_type_mapping, *this, sig);
 
  // Copy the type parameters and instantiate their bounds and defaults.
  if (!delete_type_parameters) {
    const TypeParameters& type_params =
        TypeParameters::Handle(zone, type_parameters());
    if (!type_params.IsNull()) {
      const TypeParameters& sig_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.
      sig_type_params.set_names(Array::Handle(zone, type_params.names()));
      sig_type_params.set_flags(Array::Handle(zone, type_params.flags()));
      sig.SetTypeParameters(sig_type_params);
      TypeArguments& type_args = TypeArguments::Handle(zone);
      type_args = type_params.bounds();
      if (!type_args.IsNull() && !type_args.IsInstantiated()) {
        type_args = type_args.InstantiateFrom(
            instantiator_type_arguments, function_type_arguments,
            num_free_fun_type_params, space, function_type_mapping,
            num_parent_type_args_adjustment);
      }
      sig_type_params.set_bounds(type_args);
      type_args = type_params.defaults();
      if (!type_args.IsNull() && !type_args.IsInstantiated()) {
        type_args = type_args.InstantiateFrom(
            instantiator_type_arguments, function_type_arguments,
            num_free_fun_type_params, space, function_type_mapping,
            num_parent_type_args_adjustment);
      }
      sig_type_params.set_defaults(type_args);
    }
  }
 
  type = result_type();
  if (!type.IsInstantiated()) {
    type = type.InstantiateFrom(
        instantiator_type_arguments, function_type_arguments,
        num_free_fun_type_params, space, function_type_mapping,
        num_parent_type_args_adjustment);
    // A returned null type indicates a failed instantiation in dead code that
    // must be propagated up to the caller, the optimizing compiler.
    if (type.IsNull()) {
      return FunctionType::null();
    }
  }
  sig.set_result_type(type);
  const intptr_t num_params = NumParameters();
  sig.set_num_implicit_parameters(num_implicit_parameters());
  sig.set_num_fixed_parameters(num_fixed_parameters());
  sig.SetNumOptionalParameters(NumOptionalParameters(),
                               HasOptionalPositionalParameters());
  sig.set_parameter_types(Array::Handle(Array::New(num_params, space)));
  for (intptr_t i = 0; i < num_params; i++) {
    type = ParameterTypeAt(i);
    if (!type.IsInstantiated()) {
      type = type.InstantiateFrom(
          instantiator_type_arguments, function_type_arguments,
          num_free_fun_type_params, space, function_type_mapping,
          num_parent_type_args_adjustment);
      // A returned null type indicates a failed instantiation in dead code that
      // must be propagated up to the caller, the optimizing compiler.
      if (type.IsNull()) {
        return FunctionType::null();
      }
    }
    sig.SetParameterTypeAt(i, type);
  }
  sig.set_named_parameter_names(Array::Handle(zone, named_parameter_names()));
 
  if (delete_type_parameters) {
    ASSERT(sig.IsInstantiated(kFunctions));
  }
 
  sig.SetIsFinalized();
 
  // Canonicalization is not part of instantiation.
  return sig.ptr();
}

◆ IsContravariantParameter()

bool dart::FunctionType::IsContravariantParameter	(	intptr_t	parameter_position,
		const FunctionType &	other,
		intptr_t	other_parameter_position,
		Heap::Space	space,
		FunctionTypeMapping *	function_type_equivalence
	)		const

Definition at line 10042 of file object.cc.

                                                          {
  const AbstractType& param_type =
      AbstractType::Handle(ParameterTypeAt(parameter_position));
  if (param_type.IsTopTypeForSubtyping()) {
    return true;
  }
  const AbstractType& other_param_type =
      AbstractType::Handle(other.ParameterTypeAt(other_parameter_position));
  return other_param_type.IsSubtypeOf(param_type, space,
                                      function_type_equivalence);
}

◆ IsEquivalent()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 22170 of file object.cc.

                                                          {
  ASSERT(!IsNull());
  if (ptr() == other.ptr()) {
    return true;
  }
  if (!other.IsFunctionType()) {
    return false;
  }
  const FunctionType& other_type = FunctionType::Cast(other);
  if ((packed_parameter_counts() != other_type.packed_parameter_counts()) ||
      (packed_type_parameter_counts() !=
       other_type.packed_type_parameter_counts())) {
    // Different number of type parameters or parameters.
    return false;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  if (!IsNullabilityEquivalent(thread, other_type, kind)) {
    return false;
  }
  if (!IsFinalized() || !other_type.IsFinalized()) {
    ASSERT(kind != TypeEquality::kCanonical);
    return false;  // Too early to decide if equal.
  }
  FunctionTypeMapping scope(zone, &function_type_equivalence, *this,
                            other_type);
 
  // Equal function types must have equal signature types and equal optional
  // named arguments.
  // Compare function type parameters and their bounds.
  // Check the type parameters and bounds of generic functions.
  if (!HasSameTypeParametersAndBounds(other_type, kind,
                                      function_type_equivalence)) {
    return false;
  }
  AbstractType& param_type = Type::Handle(zone);
  AbstractType& other_param_type = Type::Handle(zone);
  // Check the result type.
  param_type = result_type();
  other_param_type = other_type.result_type();
  if (!param_type.IsEquivalent(other_param_type, kind,
                               function_type_equivalence)) {
    return false;
  }
  // Check the types of all parameters.
  const intptr_t num_params = NumParameters();
  ASSERT(other_type.NumParameters() == num_params);
  for (intptr_t i = 0; i < num_params; i++) {
    param_type = ParameterTypeAt(i);
    other_param_type = other_type.ParameterTypeAt(i);
    // Use contravariant order in case we test for subtyping.
    if (!other_param_type.IsEquivalent(param_type, kind,
                                       function_type_equivalence)) {
      return false;
    }
  }
  if (HasOptionalNamedParameters()) {
    ASSERT(other_type.HasOptionalNamedParameters());  // Same packed counts.
    for (intptr_t i = num_fixed_parameters(); i < num_params; i++) {
      if (ParameterNameAt(i) != other_type.ParameterNameAt(i)) {
        return false;
      }
      if (IsRequiredAt(i) != other_type.IsRequiredAt(i)) {
        return false;
      }
    }
  }
  return true;
}

◆ IsGeneric() [1/2]

bool dart::FunctionType::IsGeneric ( ) const

inline

Definition at line 9727 of file object.h.

9727{ return IsGeneric(ptr()); }

◆ IsGeneric() [2/2]

static bool dart::FunctionType::IsGeneric ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9724 of file object.h.

                                             {
    return ptr->untag()->type_parameters() != TypeParameters::null();
  }

◆ IsInstantiated()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 10850 of file object.cc.

                                                                           {
  if (num_free_fun_type_params == kCurrentAndEnclosingFree) {
    num_free_fun_type_params = kAllFree;
  } else if (genericity != kCurrentClass) {
    const intptr_t num_parent_type_args = NumParentTypeArguments();
    if (num_parent_type_args > 0 && num_free_fun_type_params > 0) {
      // The number of parent type arguments is cached in the FunctionType, so
      // we can't consider any FunctionType with free parent type arguments as
      // fully instantiated. Instead, the FunctionType must be instantiated to
      // reduce the number of parent type arguments, even if they're unused in
      // its component types.
      return false;
    }
    // Don't consider local function type parameters as free.
    if (num_free_fun_type_params > num_parent_type_args) {
      num_free_fun_type_params = num_parent_type_args;
    }
  }
  AbstractType& type = AbstractType::Handle(result_type());
  if (!type.IsInstantiated(genericity, num_free_fun_type_params)) {
    return false;
  }
  const intptr_t num_parameters = NumParameters();
  for (intptr_t i = 0; i < num_parameters; i++) {
    type = ParameterTypeAt(i);
    if (!type.IsInstantiated(genericity, num_free_fun_type_params)) {
      return false;
    }
  }
  const intptr_t num_type_params = NumTypeParameters();
  if (num_type_params > 0) {
    TypeParameters& type_params = TypeParameters::Handle(type_parameters());
    if (!type_params.AllDynamicBounds()) {
      for (intptr_t i = 0; i < type_params.Length(); ++i) {
        type = type_params.BoundAt(i);
        if (!type.IsInstantiated(genericity, num_free_fun_type_params)) {
          return false;
        }
      }
    }
  }
  return true;
}

◆ IsRequiredAt()

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

Definition at line 8813 of file object.cc.

                                                    {
  if (!HasOptionalNamedParameters() || index < num_fixed_parameters()) {
    return false;
  }
  intptr_t flag_mask;
  const intptr_t flag_index = GetRequiredFlagIndex(index, &flag_mask);
  const Array& parameter_names =
      Array::Handle(untag()->named_parameter_names());
  if (flag_index >= parameter_names.Length()) {
    return false;
  }
  const intptr_t flags =
      Smi::Value(Smi::RawCast(parameter_names.At(flag_index)));
  return (flags & flag_mask) != 0;
}

◆ IsSubtypeOf()

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

Definition at line 10147 of file object.cc.

                                                          {
  TRACE_TYPE_CHECKS_VERBOSE("  FunctionType::IsSubtypeOf(%s, %s)\n",
                            ToCString(), other.ToCString());
  const intptr_t num_fixed_params = num_fixed_parameters();
  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
  const intptr_t num_opt_named_params = NumOptionalNamedParameters();
  const intptr_t other_num_fixed_params = other.num_fixed_parameters();
  const intptr_t other_num_opt_pos_params =
      other.NumOptionalPositionalParameters();
  const intptr_t other_num_opt_named_params =
      other.NumOptionalNamedParameters();
  // This signature requires the same arguments or less and accepts the same
  // arguments or more. We can ignore implicit parameters.
  const intptr_t num_ignored_params = num_implicit_parameters();
  const intptr_t other_num_ignored_params = other.num_implicit_parameters();
  if (((num_fixed_params - num_ignored_params) >
       (other_num_fixed_params - other_num_ignored_params)) ||
      ((num_fixed_params - num_ignored_params + num_opt_pos_params) <
       (other_num_fixed_params - other_num_ignored_params +
        other_num_opt_pos_params)) ||
      (num_opt_named_params < other_num_opt_named_params)) {
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (mismatch in number of parameters)\n");
    return false;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  FunctionTypeMapping scope(zone, &function_type_equivalence, *this, other);
 
  // Check the type parameters and bounds of generic functions.
  if (!HasSameTypeParametersAndBounds(other, TypeEquality::kInSubtypeTest,
                                      function_type_equivalence)) {
    TRACE_TYPE_CHECKS_VERBOSE(
        "   - result: false (mismatch in type parameters)\n");
    return false;
  }
  // Check the result type.
  const AbstractType& other_res_type =
      AbstractType::Handle(zone, other.result_type());
  // 'void Function()' is a subtype of 'Object Function()'.
  if (!other_res_type.IsTopTypeForSubtyping()) {
    const AbstractType& res_type = AbstractType::Handle(zone, result_type());
    if (!res_type.IsSubtypeOf(other_res_type, space,
                              function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE("   - result: false (result type)\n");
      return false;
    }
  }
  // Check the types of fixed and optional positional parameters.
  for (intptr_t i = 0; i < (other_num_fixed_params - other_num_ignored_params +
                            other_num_opt_pos_params);
       i++) {
    if (!IsContravariantParameter(i + num_ignored_params, other,
                                  i + other_num_ignored_params, space,
                                  function_type_equivalence)) {
      TRACE_TYPE_CHECKS_VERBOSE("   - result: false (parameter type)\n");
      return false;
    }
  }
  // Check that for each optional named parameter of type T of the other
  // function type, there exists an optional named parameter of this function
  // type with an identical name and with a type S that is a supertype of T.
  // Note that SetParameterNameAt() guarantees that names are symbols, so we
  // can compare their raw pointers.
  const int num_params = num_fixed_params + num_opt_named_params;
  const int other_num_params =
      other_num_fixed_params + other_num_opt_named_params;
  bool found_param_name;
  String& other_param_name = String::Handle(zone);
  for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
    other_param_name = other.ParameterNameAt(i);
    ASSERT(other_param_name.IsSymbol());
    found_param_name = false;
    for (intptr_t j = num_fixed_params; j < num_params; j++) {
      ASSERT(String::Handle(zone, ParameterNameAt(j)).IsSymbol());
      if (ParameterNameAt(j) == other_param_name.ptr()) {
        found_param_name = true;
        if (!IsContravariantParameter(j, other, i, space,
                                      function_type_equivalence)) {
          TRACE_TYPE_CHECKS_VERBOSE(
              "   - result: false (optional parameter type)\n");
          return false;
        }
        break;
      }
    }
    if (!found_param_name) {
      TRACE_TYPE_CHECKS_VERBOSE(
          "   - result: false (named parameter not found)\n");
      return false;
    }
  }
  // Check that for each required named parameter in this function, there's a
  // corresponding required named parameter in the other function.
  String& param_name = other_param_name;
  for (intptr_t j = num_params - num_opt_named_params; j < num_params; j++) {
    if (IsRequiredAt(j)) {
      param_name = ParameterNameAt(j);
      ASSERT(param_name.IsSymbol());
      bool found = false;
      for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
        ASSERT(String::Handle(zone, other.ParameterNameAt(i)).IsSymbol());
        if (other.ParameterNameAt(i) == param_name.ptr()) {
          found = true;
          if (!other.IsRequiredAt(i)) {
            TRACE_TYPE_CHECKS_VERBOSE(
                "   - result: false (mismatch in required named "
                "parameters)\n");
            return false;
          }
        }
      }
      if (!found) {
        TRACE_TYPE_CHECKS_VERBOSE(
            "   - result: false (required named parameter not found)\n");
        return false;
      }
    }
  }
  TRACE_TYPE_CHECKS_VERBOSE("   - result: true\n");
  return true;
}

◆ NameArrayLengthIncludingFlags()

static intptr_t dart::FunctionType::NameArrayLengthIncludingFlags ( intptr_t num_parameters )

static

◆ named_parameter_names()

ArrayPtr dart::FunctionType::named_parameter_names ( ) const

inline

Definition at line 9669 of file object.h.

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

◆ named_parameter_names_offset()

static intptr_t dart::FunctionType::named_parameter_names_offset ( )

inlinestatic

Definition at line 9673 of file object.h.

                                                 {
    return OFFSET_OF(UntaggedFunctionType, named_parameter_names_);
  }

◆ New()

FunctionTypePtr dart::FunctionType::New	(	intptr_t	num_parent_type_arguments = `0`,
		Nullability	nullability = `Nullability::kLegacy`,
		Heap::Space	space = `Heap::kOld`
	)

static

Definition at line 11682 of file object.cc.

                                                   {
  Zone* Z = Thread::Current()->zone();
  const FunctionType& result =
      FunctionType::Handle(Z, FunctionType::New(space));
  result.set_packed_parameter_counts(0);
  result.set_packed_type_parameter_counts(0);
  result.set_named_parameter_names(Object::empty_array());
  result.SetNumParentTypeArguments(num_parent_type_arguments);
  result.SetHash(0);
  result.set_flags(0);
  result.set_nullability(nullability);
  result.set_type_state(UntaggedAbstractType::kAllocated);
  result.InitializeTypeTestingStubNonAtomic(
      Code::Handle(Z, TypeTestingStubGenerator::DefaultCodeForType(result)));
  return result.ptr();
}

◆ num_fixed_parameters()

intptr_t dart::FunctionType::num_fixed_parameters ( ) const

inline

Definition at line 9575 of file object.h.

9575{ return NumFixedParametersOf(ptr()); }

dart::FunctionType::NumFixedParametersOf

static intptr_t NumFixedParametersOf(FunctionTypePtr ptr)

Definition object.h:9571

◆ num_implicit_parameters()

intptr_t dart::FunctionType::num_implicit_parameters ( ) const

inline

Definition at line 9565 of file object.h.

                                           {
    return untag()
        ->packed_parameter_counts_.Read<PackedNumImplicitParameters>();
  }

◆ NumFixedParametersOf()

static intptr_t dart::FunctionType::NumFixedParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9571 of file object.h.

                                                            {
    return ptr->untag()
        ->packed_parameter_counts_.Read<PackedNumFixedParameters>();
  }

◆ NumOptionalNamedParameters()

intptr_t dart::FunctionType::NumOptionalNamedParameters ( ) const

inline

Definition at line 9621 of file object.h.

                                              {
    return NumOptionalNamedParametersOf(ptr());
  }

◆ NumOptionalNamedParametersOf()

static intptr_t dart::FunctionType::NumOptionalNamedParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9618 of file object.h.

                                                                    {
    return HasOptionalNamedParameters(ptr) ? NumOptionalParametersOf(ptr) : 0;
  }

◆ NumOptionalParameters()

intptr_t dart::FunctionType::NumOptionalParameters ( ) const

inline

Definition at line 9605 of file object.h.

                                         {
    return NumOptionalParametersOf(ptr());
  }

◆ NumOptionalParametersOf()

static intptr_t dart::FunctionType::NumOptionalParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9601 of file object.h.

                                                               {
    return ptr->untag()
        ->packed_parameter_counts_.Read<PackedNumOptionalParameters>();
  }

◆ NumOptionalPositionalParameters()

intptr_t dart::FunctionType::NumOptionalPositionalParameters ( ) const

inline

Definition at line 9614 of file object.h.

                                                   {
    return NumOptionalPositionalParametersOf(ptr());
  }

◆ NumOptionalPositionalParametersOf()

static intptr_t dart::FunctionType::NumOptionalPositionalParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9611 of file object.h.

                                                                         {
    return HasOptionalNamedParameters(ptr) ? 0 : NumOptionalParametersOf(ptr);
  }

◆ NumParameters()

intptr_t dart::FunctionType::NumParameters ( ) const

inline

Definition at line 9628 of file object.h.

9628{ return NumParametersOf(ptr()); }

dart::FunctionType::NumParametersOf

static intptr_t NumParametersOf(FunctionTypePtr ptr)

Definition object.h:9625

◆ NumParametersOf()

static intptr_t dart::FunctionType::NumParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9625 of file object.h.

                                                       {
    return NumFixedParametersOf(ptr) + NumOptionalParametersOf(ptr);
  }

◆ NumParentTypeArguments()

intptr_t dart::FunctionType::NumParentTypeArguments ( ) const

inline

Definition at line 9550 of file object.h.

                                          {
    return NumParentTypeArgumentsOf(ptr());
  }

◆ NumParentTypeArgumentsOf()

static intptr_t dart::FunctionType::NumParentTypeArgumentsOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9545 of file object.h.

                                                                {
    return ptr->untag()
        ->packed_type_parameter_counts_.Read<PackedNumParentTypeArguments>();
  }

◆ NumTypeArguments()

intptr_t dart::FunctionType::NumTypeArguments ( ) const

inline

Definition at line 9563 of file object.h.

9563{ return NumTypeArgumentsOf(ptr()); }

dart::FunctionType::NumTypeArgumentsOf

static intptr_t NumTypeArgumentsOf(FunctionTypePtr ptr)

Definition object.h:9560

◆ NumTypeArgumentsOf()

static intptr_t dart::FunctionType::NumTypeArgumentsOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9560 of file object.h.

                                                          {
    return NumTypeParametersOf(ptr) + NumParentTypeArgumentsOf(ptr);
  }

◆ NumTypeParameters()

intptr_t dart::FunctionType::NumTypeParameters ( ) const

inline

Definition at line 9558 of file object.h.

9558{ return NumTypeParametersOf(ptr()); }

◆ NumTypeParametersOf()

static intptr_t dart::FunctionType::NumTypeParametersOf ( FunctionTypePtr ptr )

inlinestatic

Definition at line 9554 of file object.h.

                                                           {
    return ptr->untag()
        ->packed_type_parameter_counts_.Read<PackedNumTypeParameters>();
  }

◆ packed_parameter_counts()

uint32_t dart::FunctionType::packed_parameter_counts ( ) const

inline

Definition at line 9630 of file object.h.

                                           {
    return untag()->packed_parameter_counts_;
  }

◆ packed_parameter_counts_offset()

static intptr_t dart::FunctionType::packed_parameter_counts_offset ( )

inlinestatic

Definition at line 9634 of file object.h.

                                                   {
    return OFFSET_OF(UntaggedFunctionType, packed_parameter_counts_);
  }

◆ packed_type_parameter_counts()

uint16_t dart::FunctionType::packed_type_parameter_counts ( ) const

inline

Definition at line 9637 of file object.h.

                                                {
    return untag()->packed_type_parameter_counts_;
  }

◆ packed_type_parameter_counts_offset()

static intptr_t dart::FunctionType::packed_type_parameter_counts_offset ( )

inlinestatic

Definition at line 9641 of file object.h.

                                                        {
    return OFFSET_OF(UntaggedFunctionType, packed_type_parameter_counts_);
  }

◆ parameter_types()

ArrayPtr dart::FunctionType::parameter_types ( ) const

inline

Definition at line 9658 of file object.h.

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

◆ parameter_types_offset()

static intptr_t dart::FunctionType::parameter_types_offset ( )

inlinestatic

Definition at line 9660 of file object.h.

                                           {
    return OFFSET_OF(UntaggedFunctionType, parameter_types_);
  }

◆ ParameterNameAt()

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

Definition at line 8703 of file object.cc.

                                                            {
  const intptr_t num_fixed = num_fixed_parameters();
  if (!HasOptionalNamedParameters() || index < num_fixed) {
    // The positional parameter names are stored on the function, not here.
    UNREACHABLE();
  }
  const Array& parameter_names =
      Array::Handle(untag()->named_parameter_names());
  return String::RawCast(parameter_names.At(index - num_fixed));
}

◆ ParameterTypeAt()

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

Definition at line 8643 of file object.cc.

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

◆ Print()

void dart::FunctionType::Print	(	NameVisibility	name_visibility,
		BaseTextBuffer *	printer
	)		const

Definition at line 10813 of file object.cc.

                                                        {
  if (IsNull()) {
    printer->AddString("null");  // Signature optimized out in precompiler.
    return;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const TypeParameters& type_params =
      TypeParameters::Handle(zone, type_parameters());
  if (!type_params.IsNull()) {
    printer->AddString("<");
    const intptr_t base = NumParentTypeArguments();
    const bool kIsClassTypeParameter = false;
    // Type parameter names are meaningless after canonicalization.
    type_params.Print(thread, zone, kIsClassTypeParameter, base,
                      name_visibility, printer);
    printer->AddString(">");
  }
  printer->AddString("(");
  PrintParameters(thread, zone, name_visibility, printer);
  printer->AddString(") => ");
  const AbstractType& res_type = AbstractType::Handle(zone, result_type());
  if (!res_type.IsNull()) {
    res_type.PrintName(name_visibility, printer);
  } else {
    printer->AddString("null");
  }
}

◆ PrintName()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 22661 of file object.cc.

                                                            {
  const char* suffix = NullabilitySuffix(name_visibility);
  if (suffix[0] != '\0') {
    printer->AddString("(");
  }
  FunctionType::Cast(*this).Print(name_visibility, printer);
  if (suffix[0] != '\0') {
    printer->AddString(")");
    printer->AddString(suffix);
  }
}

◆ PrintParameters()

void dart::FunctionType::PrintParameters	(	Thread *	thread,
		Zone *	zone,
		NameVisibility	name_visibility,
		BaseTextBuffer *	printer
	)		const

Definition at line 10700 of file object.cc.

                                                                  {
  AbstractType& param_type = AbstractType::Handle(zone);
  const intptr_t num_params = NumParameters();
  const intptr_t num_fixed_params = num_fixed_parameters();
  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
  const intptr_t num_opt_named_params = NumOptionalNamedParameters();
  const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
  ASSERT((num_fixed_params + num_opt_params) == num_params);
  intptr_t i = 0;
  if (name_visibility == kUserVisibleName) {
    // Hide implicit parameters.
    i = num_implicit_parameters();
  }
  String& name = String::Handle(zone);
  while (i < num_fixed_params) {
    param_type = ParameterTypeAt(i);
    ASSERT(!param_type.IsNull());
    param_type.PrintName(name_visibility, printer);
    if (i != (num_params - 1)) {
      printer->AddString(", ");
    }
    i++;
  }
  if (num_opt_params > 0) {
    if (num_opt_pos_params > 0) {
      printer->AddString("[");
    } else {
      printer->AddString("{");
    }
    for (intptr_t i = num_fixed_params; i < num_params; i++) {
      if (num_opt_named_params > 0 && IsRequiredAt(i)) {
        printer->AddString("required ");
      }
      param_type = ParameterTypeAt(i);
      ASSERT(!param_type.IsNull());
      param_type.PrintName(name_visibility, printer);
      // The parameter name of an optional positional parameter does not need
      // to be part of the signature, since it is not used.
      if (num_opt_named_params > 0) {
        name = ParameterNameAt(i);
        printer->AddString(" ");
        printer->AddString(name.ToCString());
      }
      if (i != (num_params - 1)) {
        printer->AddString(", ");
      }
    }
    if (num_opt_pos_params > 0) {
      printer->AddString("]");
    } else {
      printer->AddString("}");
    }
  }
}

◆ result_type()

AbstractTypePtr dart::FunctionType::result_type ( ) const

inline

Definition at line 9650 of file object.h.

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

◆ set_named_parameter_names()

void dart::FunctionType::set_named_parameter_names ( const Array & value ) const

Definition at line 8730 of file object.cc.

                                                                     {
  ASSERT(value.ptr() == Object::empty_array().ptr() || value.Length() > 0);
  untag()->set_named_parameter_names(value.ptr());
}

◆ set_num_fixed_parameters()

void dart::FunctionType::set_num_fixed_parameters ( intptr_t value ) const

Definition at line 11659 of file object.cc.

                                                                {
  ASSERT(value >= 0);
  untag()->packed_parameter_counts_.Update<PackedNumFixedParameters>(value);
}

◆ set_num_implicit_parameters()

void dart::FunctionType::set_num_implicit_parameters ( intptr_t value ) const

Definition at line 11608 of file object.cc.

                                                                   {
  ASSERT(value >= 0);
  untag()->packed_parameter_counts_.Update<PackedNumImplicitParameters>(value);
}

◆ set_packed_parameter_counts()

void dart::FunctionType::set_packed_parameter_counts ( uint32_t packed_parameter_counts ) const

Definition at line 11598 of file object.cc.

                                            {
  untag()->packed_parameter_counts_ = packed_parameter_counts;
}

◆ set_packed_type_parameter_counts()

void dart::FunctionType::set_packed_type_parameter_counts ( uint16_t packed_parameter_counts ) const

Definition at line 11603 of file object.cc.

                                                 {
  untag()->packed_type_parameter_counts_ = packed_type_parameter_counts;
}

◆ set_parameter_types()

void dart::FunctionType::set_parameter_types ( const Array & value ) const

Definition at line 8655 of file object.cc.

                                                               {
  ASSERT(value.IsNull() || value.Length() > 0);
  untag()->set_parameter_types(value.ptr());
}

◆ set_result_type()

void dart::FunctionType::set_result_type ( const AbstractType & value ) const

Definition at line 8633 of file object.cc.

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

◆ SetIsRequiredAt()

void dart::FunctionType::SetIsRequiredAt ( intptr_t index ) const

Definition at line 8829 of file object.cc.

                                                       {
#if defined(DART_PRECOMPILER_RUNTIME)
  UNREACHABLE();
#else
  intptr_t flag_mask;
  const intptr_t flag_index = GetRequiredFlagIndex(index, &flag_mask);
  const Array& parameter_names =
      Array::Handle(untag()->named_parameter_names());
  ASSERT(flag_index < parameter_names.Length());
  const intptr_t flags =
      Smi::Value(Smi::RawCast(parameter_names.At(flag_index)));
  parameter_names.SetAt(flag_index, Smi::Handle(Smi::New(flags | flag_mask)));
#endif
}

◆ SetNumOptionalParameters()

void dart::FunctionType::SetNumOptionalParameters	(	intptr_t	num_optional_parameters,
		bool	are_optional_positional
	)		const

Definition at line 11668 of file object.cc.

                                        {
  // HasOptionalNamedParameters only checks this bit, so only set it if there
  // are actual named parameters.
  untag()->packed_parameter_counts_.Update<PackedHasNamedOptionalParameters>(
      (value > 0) && !are_optional_positional);
  untag()->packed_parameter_counts_.Update<PackedNumOptionalParameters>(value);
}

◆ SetNumParentTypeArguments()

void dart::FunctionType::SetNumParentTypeArguments ( intptr_t value ) const

Definition at line 8893 of file object.cc.

                                                                 {
  ASSERT(value >= 0);
  if (!PackedNumParentTypeArguments::is_valid(value)) {
    ReportTooManyTypeParameters(*this);
  }
  untag()->packed_type_parameter_counts_.Update<PackedNumParentTypeArguments>(
      value);
}

◆ SetParameterNameAt()

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

Definition at line 8714 of file object.cc.

                                                                 {
#if defined(DART_PRECOMPILED_RUNTIME)
  UNREACHABLE();
#else
  ASSERT(!value.IsNull() && value.IsSymbol());
  const intptr_t num_fixed = num_fixed_parameters();
  if (!HasOptionalNamedParameters() || index < num_fixed) {
    UNREACHABLE();
  }
  const Array& parameter_names =
      Array::Handle(untag()->named_parameter_names());
  parameter_names.SetAt(index - num_fixed, value);
#endif
}

◆ SetParameterTypeAt()

void dart::FunctionType::SetParameterTypeAt	(	intptr_t	index,
		const AbstractType &	value
	)		const

Definition at line 8648 of file object.cc.

                                                                       {
  ASSERT(!value.IsNull());
  const Array& parameter_types = Array::Handle(untag()->parameter_types());
  parameter_types.SetAt(index, value);
}

◆ SetTypeParameters()

void dart::FunctionType::SetTypeParameters ( const TypeParameters & value ) const

Definition at line 8884 of file object.cc.

                                                                      {
  untag()->set_type_parameters(value.ptr());
  const intptr_t count = value.Length();
  if (!UntaggedFunctionType::PackedNumTypeParameters::is_valid(count)) {
    ReportTooManyTypeParameters(*this);
  }
  untag()->packed_type_parameter_counts_.Update<PackedNumTypeParameters>(count);
}

◆ ToNullability()

FunctionTypePtr dart::FunctionType::ToNullability	(	Nullability	value,
		Heap::Space	space
	)		const

Definition at line 22005 of file object.cc.

                                                                   {
  if (nullability() == value) {
    return ptr();
  }
  // Clone function type and set new nullability.
  FunctionType& type = FunctionType::Handle(FunctionType::Clone(*this, space));
  type.set_nullability(value);
  type.SetHash(0);
  type.InitializeTypeTestingStubNonAtomic(
      Code::Handle(TypeTestingStubGenerator::DefaultCodeForType(type)));
  if (IsCanonical()) {
    // Object::Clone does not clone canonical bit.
    ASSERT(!type.IsCanonical());
    type ^= type.Canonicalize(Thread::Current());
  }
  return type.ptr();
}

◆ ToUserVisibleCString()

const char * dart::FunctionType::ToUserVisibleCString ( ) const

Definition at line 11712 of file object.cc.

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

◆ ToUserVisibleString()

StringPtr dart::FunctionType::ToUserVisibleString ( ) const

Definition at line 11719 of file object.cc.

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

◆ type_class_id()

virtual classid_t dart::FunctionType::type_class_id ( ) const

inlinevirtual

Reimplemented from dart::AbstractType.

Definition at line 9510 of file object.h.

9510{ return kIllegalCid; }

dart::kIllegalCid

@ kIllegalCid

Definition class_id.h:214

◆ type_parameters()

TypeParametersPtr dart::FunctionType::type_parameters ( ) const

inline

Definition at line 9707 of file object.h.

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

◆ type_parameters_offset()

static intptr_t dart::FunctionType::type_parameters_offset ( )

inlinestatic

Definition at line 9711 of file object.h.

                                           {
    return OFFSET_OF(UntaggedFunctionType, type_parameters_);
  }

◆ TypeParameterAt()

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

Definition at line 8618 of file object.cc.

                                                                              {
  ASSERT(index >= 0 && index < NumTypeParameters());
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  TypeParameter& type_param = TypeParameter::Handle(
      zone, TypeParameter::New(*this, NumParentTypeArguments(),
                               NumParentTypeArguments() + index, nullability));
  type_param.SetIsFinalized();
  if (IsFinalized()) {
    type_param ^= type_param.Canonicalize(thread);
  }
  return type_param.ptr();
}

◆ UpdateFunctionTypes()

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

virtual

Reimplemented from dart::AbstractType.

Definition at line 9961 of file object.cc.

                                                      {
  ASSERT(num_parent_type_args_adjustment >= 0);
  ASSERT(IsFinalized());
  Zone* zone = Thread::Current()->zone();
 
  const intptr_t old_num_parent_type_args = NumParentTypeArguments();
  // From now on, adjust all type parameter types
  // which belong to this or nested function types.
  if (num_free_fun_type_params > old_num_parent_type_args) {
    num_free_fun_type_params = old_num_parent_type_args;
  }
 
  FunctionType& new_type = FunctionType::Handle(
      zone, FunctionType::New(
                NumParentTypeArguments() + num_parent_type_args_adjustment,
                nullability(), space));
  AbstractType& type = AbstractType::Handle(zone);
 
  FunctionTypeMapping scope(zone, &function_type_mapping, *this, new_type);
 
  const TypeParameters& type_params =
      TypeParameters::Handle(zone, type_parameters());
  if (!type_params.IsNull()) {
    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, type_params.names()));
    new_type_params.set_flags(Array::Handle(zone, type_params.flags()));
    TypeArguments& type_args = TypeArguments::Handle(zone);
    type_args = type_params.bounds();
    if (!type_args.IsNull()) {
      type_args = type_args.UpdateFunctionTypes(num_parent_type_args_adjustment,
                                                num_free_fun_type_params, space,
                                                function_type_mapping);
    }
    new_type_params.set_bounds(type_args);
    type_args = type_params.defaults();
    if (!type_args.IsNull()) {
      type_args = type_args.UpdateFunctionTypes(num_parent_type_args_adjustment,
                                                num_free_fun_type_params, space,
                                                function_type_mapping);
    }
    new_type_params.set_defaults(type_args);
    new_type.SetTypeParameters(new_type_params);
  }
 
  type = result_type();
  type = type.UpdateFunctionTypes(num_parent_type_args_adjustment,
                                  num_free_fun_type_params, space,
                                  function_type_mapping);
  new_type.set_result_type(type);
 
  const intptr_t num_params = NumParameters();
  new_type.set_num_implicit_parameters(num_implicit_parameters());
  new_type.set_num_fixed_parameters(num_fixed_parameters());
  new_type.SetNumOptionalParameters(NumOptionalParameters(),
                                    HasOptionalPositionalParameters());
  new_type.set_parameter_types(Array::Handle(Array::New(num_params, space)));
  for (intptr_t i = 0; i < num_params; i++) {
    type = ParameterTypeAt(i);
    type = type.UpdateFunctionTypes(num_parent_type_args_adjustment,
                                    num_free_fun_type_params, space,
                                    function_type_mapping);
    new_type.SetParameterTypeAt(i, type);
  }
  new_type.set_named_parameter_names(
      Array::Handle(zone, named_parameter_names()));
  new_type.SetIsFinalized();
 
  return new_type.ptr();
}

Friends And Related Symbol Documentation

◆ Class

friend class Class

friend

Definition at line 9772 of file object.h.

◆ Function

friend class Function

friend

Definition at line 9773 of file object.h.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ PackedHasNamedOptionalParameters

◆ PackedNumFixedParameters

◆ PackedNumImplicitParameters

◆ PackedNumOptionalParameters

◆ PackedNumParentTypeArguments

◆ PackedNumTypeParameters

Member Function Documentation

◆ Canonicalize()

◆ Clone()

◆ ComputeHash()

◆ ContainsHandles()

◆ CreateNameArrayIncludingFlags()

◆ EnumerateURIs()

◆ FinalizeNameArray()

◆ GetRequiredFlagIndex()

◆ HasGenericParent()

◆ HasOptionalNamedParameters() [1/2]

◆ HasOptionalNamedParameters() [2/2]

◆ HasOptionalParameters() [1/2]

◆ HasOptionalParameters() [2/2]

◆ HasOptionalPositionalParameters() [1/2]

◆ HasOptionalPositionalParameters() [2/2]

◆ HasRequiredNamedParameters()

◆ HasSameTypeParametersAndBounds()

◆ HasTypeClass()

◆ InstanceSize()

◆ InstantiateFrom()

◆ IsContravariantParameter()

◆ IsEquivalent()

◆ IsGeneric() [1/2]

◆ IsGeneric() [2/2]

◆ IsInstantiated()

◆ IsRequiredAt()

◆ IsSubtypeOf()

◆ NameArrayLengthIncludingFlags()

◆ named_parameter_names()

◆ named_parameter_names_offset()

◆ New()

◆ num_fixed_parameters()

◆ num_implicit_parameters()

◆ NumFixedParametersOf()

◆ NumOptionalNamedParameters()

◆ NumOptionalNamedParametersOf()

◆ NumOptionalParameters()

◆ NumOptionalParametersOf()

◆ NumOptionalPositionalParameters()

◆ NumOptionalPositionalParametersOf()

◆ NumParameters()

◆ NumParametersOf()

◆ NumParentTypeArguments()

◆ NumParentTypeArgumentsOf()

◆ NumTypeArguments()

◆ NumTypeArgumentsOf()

◆ NumTypeParameters()

◆ NumTypeParametersOf()

◆ packed_parameter_counts()

◆ packed_parameter_counts_offset()

◆ packed_type_parameter_counts()

◆ packed_type_parameter_counts_offset()

◆ parameter_types()

◆ parameter_types_offset()

◆ ParameterNameAt()

◆ ParameterTypeAt()

◆ Print()

◆ PrintName()

◆ PrintParameters()

◆ result_type()

◆ set_named_parameter_names()

◆ set_num_fixed_parameters()

◆ set_num_implicit_parameters()

◆ set_packed_parameter_counts()

◆ set_packed_type_parameter_counts()

◆ set_parameter_types()