#include <object.h>

Inheritance diagram for dart::TypeArguments:

Classes
struct	ArrayTraits

class	Cache

Public Member Functions
bool	HasCount (intptr_t count) const

intptr_t	Length () const

AbstractTypePtr	TypeAt (intptr_t index) const

AbstractTypePtr	TypeAtNullSafe (intptr_t index) const

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

intptr_t	nullability () const

StringPtr	Name () const

StringPtr	UserVisibleName () const

void	PrintSubvectorName (intptr_t from_index, intptr_t len, NameVisibility name_visibility, BaseTextBuffer *printer) const

void	PrintTo (BaseTextBuffer *printer) const

bool	IsRaw (intptr_t from_index, intptr_t len) const

bool	IsRawWhenInstantiatedFromRaw (intptr_t len) const

TypeArgumentsPtr	Prepend (Zone *zone, const TypeArguments &other, intptr_t other_length, intptr_t total_length) const

TypeArgumentsPtr	ConcatenateTypeParameters (Zone *zone, const TypeArguments &other) const

InstantiationMode	GetInstantiationMode (Zone zone, const Function function=nullptr, const Class *cls=nullptr) const

bool	Equals (const TypeArguments &other) const

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

bool	IsSubvectorEquivalent (const TypeArguments &other, intptr_t from_index, intptr_t len, TypeEquality kind, FunctionTypeMapping *function_type_equivalence=nullptr) const

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

bool	IsSubvectorInstantiated (intptr_t from_index, intptr_t len, Genericity genericity=kAny, intptr_t num_free_fun_type_params=kAllFree) const

bool	IsUninstantiatedIdentity () const

bool	CanShareInstantiatorTypeArguments (const Class &instantiator_class, bool *with_runtime_check=nullptr) const

bool	CanShareFunctionTypeArguments (const Function &function, bool *with_runtime_check=nullptr) const

TypeArgumentsPtr	TruncatedTo (intptr_t length) const

bool	IsFinalized () const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

TypeArgumentsPtr	Canonicalize (Thread *thread) const

TypeArgumentsPtr	FromInstanceTypeArguments (Thread *thread, const Class &cls) const

TypeArgumentsPtr	ToInstantiatorTypeArguments (Thread *thread, const Class &cls) const

void	EnumerateURIs (URIs *uris) const

TypeArgumentsPtr	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

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

TypeArgumentsPtr	InstantiateAndCanonicalizeFrom (const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments) const

bool	HasInstantiations () const

virtual uint32_t	CanonicalizeHash () const

uword	Hash () const

uword	HashForRange (intptr_t from_index, intptr_t len) const

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

bool	IsIdenticalTo (const Instance &other) const

virtual bool	CanonicalizeEquals (const Instance &other) const

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

static intptr_t	types_offset ()

static intptr_t	type_at_offset (intptr_t index)

static intptr_t	nullability_offset ()

static intptr_t	instantiations_offset ()

static intptr_t	InstanceSize ()

static intptr_t	InstanceSize (intptr_t len)

static intptr_t	hash_offset ()

static TypeArgumentsPtr	New (intptr_t len, Heap::Space space=Heap::kOld)

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)

Static Public Attributes
static constexpr intptr_t	kAllDynamicHash = 1

static constexpr intptr_t	kNullabilityBitsPerType = 2

static constexpr intptr_t	kNullabilityMaxTypes

static constexpr intptr_t	kNonNullableBits = 0

static constexpr intptr_t	kNullableBits = 3

static constexpr intptr_t	kLegacyBits = 2

static constexpr intptr_t	kBytesPerElement = kCompressedWordSize

static constexpr intptr_t	kMaxElements = kSmiMax / kBytesPerElement

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

static const ClassId	kClassId = kObjectCid

Friends
class	AbstractType

class	Class

class	ClearTypeHashVisitor

class	Object

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

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

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

Member Function Documentation

◆ Canonicalize()

TypeArgumentsPtr dart::TypeArguments::Canonicalize ( Thread * thread ) const

Definition at line 7761 of file object.cc.

                                                                 {
  if (IsNull() || IsCanonical()) {
    ASSERT(IsOld());
    return this->ptr();
  }
  const intptr_t num_types = Length();
  if (num_types == 0) {
    return TypeArguments::empty_type_arguments().ptr();
  } else if (IsRaw(0, num_types)) {
    return TypeArguments::null();
  }
  Zone* zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  ObjectStore* object_store = isolate_group->object_store();
  TypeArguments& result = TypeArguments::Handle(zone);
  {
    SafepointMutexLocker ml(isolate_group->type_canonicalization_mutex());
    CanonicalTypeArgumentsSet table(zone,
                                    object_store->canonical_type_arguments());
    result ^= table.GetOrNull(CanonicalTypeArgumentsKey(*this));
    object_store->set_canonical_type_arguments(table.Release());
  }
  if (result.IsNull()) {
    // Canonicalize each type argument.
    AbstractType& type_arg = AbstractType::Handle(zone);
    GrowableHandlePtrArray<const AbstractType> canonicalized_types(zone,
                                                                   num_types);
    for (intptr_t i = 0; i < num_types; i++) {
      type_arg = TypeAt(i);
      type_arg = type_arg.Canonicalize(thread);
      canonicalized_types.Add(type_arg);
    }
    SafepointMutexLocker ml(isolate_group->type_canonicalization_mutex());
    CanonicalTypeArgumentsSet table(zone,
                                    object_store->canonical_type_arguments());
    // Since we canonicalized some type arguments above we need to lookup
    // in the table again to make sure we don't already have an equivalent
    // canonical entry.
    result ^= table.GetOrNull(CanonicalTypeArgumentsKey(*this));
    if (result.IsNull()) {
      for (intptr_t i = 0; i < num_types; i++) {
        SetTypeAt(i, canonicalized_types.At(i));
      }
      // Make sure we have an old space object and add it to the table.
      if (this->IsNew()) {
        result ^= Object::Clone(*this, Heap::kOld);
      } else {
        result = this->ptr();
      }
      ASSERT(result.IsOld());
      result.ComputeNullability();
      result.SetCanonical();  // Mark object as being canonical.
      // Now add this TypeArgument into the canonical list of type arguments.
      bool present = table.Insert(result);
      ASSERT(!present);
    }
    object_store->set_canonical_type_arguments(table.Release());
  }
  ASSERT(result.Equals(*this));
  ASSERT(!result.IsNull());
  ASSERT(result.IsTypeArguments());
  ASSERT(result.IsCanonical());
  return result.ptr();
}

◆ CanonicalizeHash()

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

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 8978 of file object.h.

                                            {
    // Hash() is not stable until finalization is done.
    return 0;
  }

◆ CanonicalizeLocked()

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

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 8711 of file object.h.

                                                               {
    return Canonicalize(thread);
  }

◆ CanShareFunctionTypeArguments()

bool dart::TypeArguments::CanShareFunctionTypeArguments	(	const Function &	function,
		bool *	with_runtime_check = `nullptr`
	)		const

Definition at line 7530 of file object.cc.

                                    {
  ASSERT(!IsInstantiated());
  if (with_runtime_check != nullptr) {
    *with_runtime_check = false;
  }
  const intptr_t num_type_args = Length();
  const intptr_t num_parent_type_args = function.NumParentTypeArguments();
  const intptr_t num_function_type_params = function.NumTypeParameters();
  const intptr_t num_function_type_args =
      num_parent_type_args + num_function_type_params;
  if (num_type_args > num_function_type_args) {
    // This vector cannot be a prefix of a shorter vector.
    return false;
  }
  AbstractType& type_arg = AbstractType::Handle();
  for (intptr_t i = 0; i < num_type_args; i++) {
    type_arg = TypeAt(i);
    if (!type_arg.IsTypeParameter()) {
      return false;
    }
    const TypeParameter& type_param = TypeParameter::Cast(type_arg);
    ASSERT(type_param.IsFinalized());
    if ((type_param.index() != i) || !type_param.IsFunctionTypeParameter()) {
      return false;
    }
    // Instantiating nullable and legacy type parameters may change nullability
    // of a type, so type arguments vector containing such type parameters
    // cannot be substituted with the enclosing function type arguments, unless
    // we check at runtime the nullability of the first 1 or 2 type arguments of
    // the enclosing function type arguments.
    if (type_param.IsNullable() || type_param.IsLegacy()) {
      if (with_runtime_check == nullptr || i >= kNullabilityMaxTypes) {
        return false;
      }
      *with_runtime_check = true;
    }
  }
  return true;
}

◆ CanShareInstantiatorTypeArguments()

bool dart::TypeArguments::CanShareInstantiatorTypeArguments	(	const Class &	instantiator_class,
		bool *	with_runtime_check = `nullptr`
	)		const

Definition at line 7442 of file object.cc.

                                    {
  ASSERT(!IsInstantiated());
  if (with_runtime_check != nullptr) {
    *with_runtime_check = false;
  }
  const intptr_t num_type_args = Length();
  const intptr_t num_instantiator_type_args =
      instantiator_class.NumTypeArguments();
  if (num_type_args > num_instantiator_type_args) {
    // This vector cannot be a prefix of a shorter vector.
    return false;
  }
  const intptr_t num_instantiator_type_params =
      instantiator_class.NumTypeParameters();
  const intptr_t first_type_param_offset =
      num_instantiator_type_args - num_instantiator_type_params;
  // At compile time, the type argument vector of the instantiator consists of
  // the type argument vector of its super type, which may refer to the type
  // parameters of the instantiator class, followed by (or overlapping partially
  // or fully with) the type parameters of the instantiator class in declaration
  // order.
  // In other words, the only variables are the type parameters of the
  // instantiator class.
  // This uninstantiated type argument vector is also expressed in terms of the
  // type parameters of the instantiator class. Therefore, in order to be a
  // prefix once instantiated at runtime, every one of its type argument must be
  // equal to the type argument of the instantiator vector at the same index.
 
  // As a first requirement, the last num_instantiator_type_params type
  // arguments of this type argument vector must refer to the corresponding type
  // parameters of the instantiator class.
  AbstractType& type_arg = AbstractType::Handle();
  for (intptr_t i = first_type_param_offset; i < num_type_args; i++) {
    type_arg = TypeAt(i);
    if (!type_arg.IsTypeParameter()) {
      return false;
    }
    const TypeParameter& type_param = TypeParameter::Cast(type_arg);
    ASSERT(type_param.IsFinalized());
    if ((type_param.index() != i) || type_param.IsFunctionTypeParameter()) {
      return false;
    }
    // Instantiating nullable and legacy type parameters may change nullability
    // of a type, so type arguments vector containing such type parameters
    // cannot be substituted with instantiator type arguments, unless we check
    // at runtime the nullability of the first 1 or 2 type arguments of the
    // instantiator.
    // Note that the presence of non-overlapping super type arguments (i.e.
    // first_type_param_offset > 0) will prevent this optimization.
    if (type_param.IsNullable() || type_param.IsLegacy()) {
      if (with_runtime_check == nullptr || i >= kNullabilityMaxTypes) {
        return false;
      }
      *with_runtime_check = true;
    }
  }
  // As a second requirement, the type arguments corresponding to the super type
  // must be identical. Overlapping ones have already been checked starting at
  // first_type_param_offset.
  if (first_type_param_offset == 0) {
    return true;
  }
  Type& super_type = Type::Handle(instantiator_class.super_type());
  const TypeArguments& super_type_args =
      TypeArguments::Handle(super_type.GetInstanceTypeArguments(
          Thread::Current(), /*canonicalize=*/false));
  if (super_type_args.IsNull()) {
    ASSERT(!IsUninstantiatedIdentity());
    return false;
  }
  AbstractType& super_type_arg = AbstractType::Handle();
  for (intptr_t i = 0; (i < first_type_param_offset) && (i < num_type_args);
       i++) {
    type_arg = TypeAt(i);
    super_type_arg = super_type_args.TypeAt(i);
    if (!type_arg.Equals(super_type_arg)) {
      ASSERT(!IsUninstantiatedIdentity());
      return false;
    }
  }
  return true;
}

◆ ConcatenateTypeParameters()

TypeArgumentsPtr dart::TypeArguments::ConcatenateTypeParameters	(	Zone *	zone,
		const TypeArguments &	other
	)		const

Definition at line 6885 of file object.cc.

                                      {
  ASSERT(!IsNull() && !other.IsNull());
  const intptr_t this_len = Length();
  const intptr_t other_len = other.Length();
  const auto& result = TypeArguments::Handle(
      zone, TypeArguments::New(this_len + other_len, Heap::kNew));
  auto& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < this_len; ++i) {
    type = TypeAt(i);
    result.SetTypeAt(i, type);
  }
  for (intptr_t i = 0; i < other_len; ++i) {
    type = other.TypeAt(i);
    result.SetTypeAt(this_len + i, type);
  }
  return result.ptr();
}

◆ EnumerateURIs()

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

Definition at line 7877 of file object.cc.

                                                  {
  if (IsNull()) {
    return;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  AbstractType& type = AbstractType::Handle(zone);
  const intptr_t num_types = Length();
  for (intptr_t i = 0; i < num_types; i++) {
    type = TypeAt(i);
    type.EnumerateURIs(uris);
  }
}

◆ Equals()

bool dart::TypeArguments::Equals ( const TypeArguments & other ) const

inline

Definition at line 8660 of file object.h.

                                                {
    return IsSubvectorEquivalent(other, 0, IsNull() ? 0 : Length(),
                                 TypeEquality::kCanonical);
  }

◆ FromInstanceTypeArguments()

TypeArgumentsPtr dart::TypeArguments::FromInstanceTypeArguments	(	Thread *	thread,
		const Class &	cls
	)		const

Definition at line 7826 of file object.cc.

                            {
  if (IsNull()) {
    return ptr();
  }
  const intptr_t num_type_arguments = cls.NumTypeArguments();
  const intptr_t num_type_parameters = cls.NumTypeParameters(thread);
  ASSERT(Length() >= num_type_arguments);
  if (Length() == num_type_parameters) {
    return ptr();
  }
  if (num_type_parameters == 0) {
    return TypeArguments::null();
  }
  Zone* zone = thread->zone();
  const auto& args =
      TypeArguments::Handle(zone, TypeArguments::New(num_type_parameters));
  const intptr_t offset = num_type_arguments - num_type_parameters;
  auto& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < num_type_parameters; ++i) {
    type = TypeAt(offset + i);
    args.SetTypeAt(i, type);
  }
  return args.ptr();
}

◆ GetInstantiationMode()

InstantiationMode dart::TypeArguments::GetInstantiationMode	(	Zone *	zone,
		const Function *	function = `nullptr`,
		const Class *	cls = `nullptr`
	)		const

Definition at line 6905 of file object.cc.

                                                                              {
  if (IsNull() || IsInstantiated()) {
    return InstantiationMode::kIsInstantiated;
  }
  if (function != nullptr) {
    if (CanShareFunctionTypeArguments(*function)) {
      return InstantiationMode::kSharesFunctionTypeArguments;
    }
    if (cls == nullptr) {
      cls = &Class::Handle(zone, function->Owner());
    }
  }
  if (cls != nullptr) {
    if (CanShareInstantiatorTypeArguments(*cls)) {
      return InstantiationMode::kSharesInstantiatorTypeArguments;
    }
  }
  return InstantiationMode::kNeedsInstantiation;
}

◆ HasCount()

bool dart::TypeArguments::HasCount ( intptr_t count ) const

Definition at line 7345 of file object.cc.

                                                 {
  if (IsNull()) {
    return true;
  }
  return Length() == count;
}

◆ Hash()

uword dart::TypeArguments::Hash ( ) const

inline

Definition at line 13370 of file object.h.

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

◆ hash_offset()

static intptr_t dart::TypeArguments::hash_offset ( )

inlinestatic

Definition at line 8984 of file object.h.

                                {
    return OFFSET_OF(UntaggedTypeArguments, hash_);
  }

◆ HashForRange()

uword dart::TypeArguments::HashForRange	(	intptr_t	from_index,
		intptr_t	len
	)		const

Definition at line 6836 of file object.cc.

                                                                         {
  if (IsNull()) return kAllDynamicHash;
  if (IsRaw(from_index, len)) return kAllDynamicHash;
  uint32_t result = 0;
  AbstractType& type = AbstractType::Handle();
  for (intptr_t i = 0; i < len; i++) {
    type = TypeAt(from_index + i);
    ASSERT(!type.IsNull());
    result = CombineHashes(result, type.Hash());
  }
  result = FinalizeHash(result, kHashBits);
  return result;
}

◆ HasInstantiations()

bool dart::TypeArguments::HasInstantiations ( ) const

Definition at line 7327 of file object.cc.

                                            {
  return instantiations() != Cache::EmptyStorage().ptr();
}

◆ InstanceSize() [1/2]

static intptr_t dart::TypeArguments::InstanceSize ( )

inlinestatic

Definition at line 8962 of file object.h.

                                 {
    ASSERT(sizeof(UntaggedTypeArguments) ==
           OFFSET_OF_RETURNED_VALUE(UntaggedTypeArguments, types));
    return 0;
  }

◆ InstanceSize() [2/2]

static intptr_t dart::TypeArguments::InstanceSize ( intptr_t len )

inlinestatic

Definition at line 8968 of file object.h.

                                             {
    // Ensure that the types() is not adding to the object size, which includes
    // 4 fields: instantiations_, length_, hash_, and nullability_.
    ASSERT(sizeof(UntaggedTypeArguments) ==
           (sizeof(UntaggedObject) + (kNumFields * kCompressedWordSize)));
    ASSERT(0 <= len && len <= kMaxElements);
    return RoundedAllocationSize(sizeof(UntaggedTypeArguments) +
                                 (len * kBytesPerElement));
  }

◆ InstantiateAndCanonicalizeFrom()

TypeArgumentsPtr dart::TypeArguments::InstantiateAndCanonicalizeFrom	(	const TypeArguments &	instantiator_type_arguments,
		const TypeArguments &	function_type_arguments
	)		const

Definition at line 7678 of file object.cc.

                                                        {
  auto thread = Thread::Current();
  auto zone = thread->zone();
  SafepointMutexLocker ml(
      thread->isolate_group()->type_arguments_canonicalization_mutex());
 
  ASSERT(!IsInstantiated());
  ASSERT(instantiator_type_arguments.IsNull() ||
         instantiator_type_arguments.IsCanonical());
  ASSERT(function_type_arguments.IsNull() ||
         function_type_arguments.IsCanonical());
  // Lookup instantiators and if found, return instantiated result.
  Cache cache(zone, *this);
  auto const loc = cache.FindKeyOrUnused(instantiator_type_arguments,
                                         function_type_arguments);
  if (loc.present) {
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
    if (TESTING_runtime_fail_on_existing_cache_entry) {
      TextBuffer buffer(1024);
      buffer.Printf("for\n");
      buffer.Printf("  * uninstantiated type arguments %s\n", ToCString());
      buffer.Printf("  * instantiation type arguments: %s (hash: %" Pu ")\n",
                    instantiator_type_arguments.ToCString(),
                    instantiator_type_arguments.Hash());
      buffer.Printf("  * function type arguments: %s (hash: %" Pu ")\n",
                    function_type_arguments.ToCString(),
                    function_type_arguments.Hash());
      buffer.Printf("  * number of occupied entries in cache: %" Pd "\n",
                    cache.NumOccupied());
      buffer.Printf("  * number of total entries in cache: %" Pd "\n",
                    cache.NumEntries());
      buffer.Printf("expected to find entry %" Pd
                    " of cache in stub, but reached runtime",
                    loc.entry);
      FATAL("%s", buffer.buffer());
    }
#endif
    return cache.Retrieve(loc.entry);
  }
  // Cache lookup failed. Instantiate the type arguments.
  TypeArguments& result = TypeArguments::Handle(zone);
  result = InstantiateFrom(instantiator_type_arguments, function_type_arguments,
                           kAllFree, Heap::kOld);
  // Canonicalize type arguments.
  result = result.Canonicalize(thread);
  // InstantiateAndCanonicalizeFrom is not reentrant. It cannot have been called
  // indirectly, so the prior_instantiations array cannot have grown.
  ASSERT(cache.data_.ptr() == instantiations());
  cache.AddEntry(loc.entry, instantiator_type_arguments,
                 function_type_arguments, result);
  return result.ptr();
}

◆ InstantiateFrom()

TypeArgumentsPtr dart::TypeArguments::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

Definition at line 7598 of file object.cc.

                                                    {
  ASSERT(!IsInstantiated());
  if ((instantiator_type_arguments.IsNull() ||
       instantiator_type_arguments.Length() == Length()) &&
      IsUninstantiatedIdentity()) {
    return instantiator_type_arguments.ptr();
  }
  const intptr_t num_types = Length();
  TypeArguments& instantiated_array =
      TypeArguments::Handle(TypeArguments::New(num_types, space));
  AbstractType& type = AbstractType::Handle();
  for (intptr_t i = 0; i < num_types; i++) {
    type = TypeAt(i);
    // If this type argument T is null, the type A containing T in its flattened
    // type argument vector V is recursive and is still being finalized.
    // T is the type argument of a super type of A. T is being instantiated
    // during finalization of V, which is also the instantiator. T depends
    // solely on the type parameters of A and will be replaced by a non-null
    // type before A is marked as finalized.
    if (!type.IsNull() && !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 Object::empty_type_arguments().ptr();
      }
    }
    instantiated_array.SetTypeAt(i, type);
  }
  return instantiated_array.ptr();
}

◆ instantiations_offset()

static intptr_t dart::TypeArguments::instantiations_offset ( )

inlinestatic

Definition at line 8955 of file object.h.

                                          {
    return OFFSET_OF(UntaggedTypeArguments, instantiations_);
  }

◆ IsEquivalent()

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

inline

Definition at line 8665 of file object.h.

                                                                      {
    // Make a null vector a vector of dynamic as long as the other vector.
    return IsSubvectorEquivalent(other, 0, IsNull() ? other.Length() : Length(),
                                 kind, function_type_equivalence);
  }

◆ IsFinalized()

bool dart::TypeArguments::IsFinalized ( ) const

Definition at line 7585 of file object.cc.

                                      {
  ASSERT(!IsNull());
  AbstractType& type = AbstractType::Handle();
  const intptr_t num_types = Length();
  for (intptr_t i = 0; i < num_types; i++) {
    type = TypeAt(i);
    if (!type.IsFinalized()) {
      return false;
    }
  }
  return true;
}

◆ IsInstantiated()

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

inline

Definition at line 8681 of file object.h.

                                                                          {
    return IsSubvectorInstantiated(0, Length(), genericity,
                                   num_free_fun_type_params);
  }

◆ IsRaw()

bool dart::TypeArguments::IsRaw	(	intptr_t	from_index,
		intptr_t	len
	)		const

inline

Definition at line 8620 of file object.h.

                                                      {
    return IsDynamicTypes(false, from_index, len);
  }

◆ IsRawWhenInstantiatedFromRaw()

bool dart::TypeArguments::IsRawWhenInstantiatedFromRaw ( intptr_t len ) const

inline

Definition at line 8630 of file object.h.

                                                        {
    return IsDynamicTypes(true, 0, len);
  }

◆ IsSubvectorEquivalent()

bool dart::TypeArguments::IsSubvectorEquivalent	(	const TypeArguments &	other,
		intptr_t	from_index,
		intptr_t	len,
		TypeEquality	kind,
		FunctionTypeMapping *	function_type_equivalence = `nullptr`
	)		const

Definition at line 6978 of file object.cc.

                                                          {
  if (this->ptr() == other.ptr()) {
    return true;
  }
  if (kind == TypeEquality::kCanonical) {
    if (IsNull() || other.IsNull()) {
      return false;
    }
    if (Length() != other.Length()) {
      return false;
    }
  }
  AbstractType& type = AbstractType::Handle();
  AbstractType& other_type = AbstractType::Handle();
  for (intptr_t i = from_index; i < from_index + len; i++) {
    type = IsNull() ? Type::DynamicType() : TypeAt(i);
    ASSERT(!type.IsNull());
    other_type = other.IsNull() ? Type::DynamicType() : other.TypeAt(i);
    ASSERT(!other_type.IsNull());
    if (!type.IsEquivalent(other_type, kind, function_type_equivalence)) {
      return false;
    }
  }
  return true;
}

◆ IsSubvectorInstantiated()

bool dart::TypeArguments::IsSubvectorInstantiated	(	intptr_t	from_index,
		intptr_t	len,
		Genericity	genericity = `kAny`,
		intptr_t	num_free_fun_type_params = `kAllFree`
	)		const

Definition at line 7387 of file object.cc.

                                             {
  ASSERT(!IsNull());
  AbstractType& type = AbstractType::Handle();
  for (intptr_t i = 0; i < len; i++) {
    type = TypeAt(from_index + i);
    // If this type argument T is null, the type A containing T in its flattened
    // type argument vector V is recursive and is still being finalized.
    // T is the type argument of a super type of A. T is being instantiated
    // during finalization of V, which is also the instantiator. T depends
    // solely on the type parameters of A and will be replaced by a non-null
    // type before A is marked as finalized.
    if (!type.IsNull() &&
        !type.IsInstantiated(genericity, num_free_fun_type_params)) {
      return false;
    }
  }
  return true;
}

◆ IsUninstantiatedIdentity()

bool dart::TypeArguments::IsUninstantiatedIdentity ( ) const

Definition at line 7410 of file object.cc.

                                                   {
  AbstractType& type = AbstractType::Handle();
  const intptr_t num_types = Length();
  for (intptr_t i = 0; i < num_types; i++) {
    type = TypeAt(i);
    if (type.IsNull()) {
      return false;  // Still unfinalized, too early to tell.
    }
    if (!type.IsTypeParameter()) {
      return false;
    }
    const TypeParameter& type_param = TypeParameter::Cast(type);
    ASSERT(type_param.IsFinalized());
    if ((type_param.index() != i) || type_param.IsFunctionTypeParameter()) {
      return false;
    }
    // Instantiating nullable and legacy type parameters may change
    // nullability of a type, so type arguments vector containing such type
    // parameters cannot be substituted with instantiator type arguments.
    if (type_param.IsNullable() || type_param.IsLegacy()) {
      return false;
    }
  }
  return true;
  // Note that it is not necessary to verify at runtime that the instantiator
  // type vector is long enough, since this uninstantiated vector contains as
  // many different type parameters as it is long.
}

◆ Length()

intptr_t dart::TypeArguments::Length ( ) const

Definition at line 7352 of file object.cc.

                                     {
  if (IsNull()) {
    return 0;
  }
  return Smi::Value(untag()->length());
}

◆ length_offset()

static intptr_t dart::TypeArguments::length_offset ( )

inlinestatic

Definition at line 8554 of file object.h.

                                  {
    return OFFSET_OF(UntaggedTypeArguments, length_);
  }

◆ Name()

StringPtr dart::TypeArguments::Name ( ) const

Definition at line 6927 of file object.cc.

                                    {
  Thread* thread = Thread::Current();
  ZoneTextBuffer printer(thread->zone());
  PrintSubvectorName(0, Length(), kInternalName, &printer);
  return Symbols::New(thread, printer.buffer());
}

◆ New()

TypeArgumentsPtr dart::TypeArguments::New	(	intptr_t	len,
		Heap::Space	space = `Heap::kOld`
	)

static

Definition at line 7733 of file object.cc.

                                                                 {
  if (len < 0 || len > kMaxElements) {
    // This should be caught before we reach here.
    FATAL("Fatal error in TypeArguments::New: invalid len %" Pd "\n", len);
  }
  TypeArguments& result = TypeArguments::Handle();
  {
    auto raw = Object::Allocate<TypeArguments>(space, len);
    NoSafepointScope no_safepoint;
    result = raw;
    // Length must be set before we start storing into the array.
    result.SetLength(len);
    result.SetHash(0);
    result.set_nullability(0);
  }
  // The array used as storage for an empty linear cache should be initialized.
  ASSERT(Cache::EmptyStorage().ptr() != Array::null());
  result.set_instantiations(Cache::EmptyStorage());
  return result.ptr();
}

◆ nullability()

intptr_t dart::TypeArguments::nullability ( ) const

Definition at line 7359 of file object.cc.

                                          {
  if (IsNull()) {
    return 0;
  }
  return Smi::Value(untag()->nullability());
}

◆ nullability_offset()

static intptr_t dart::TypeArguments::nullability_offset ( )

inlinestatic

Definition at line 8599 of file object.h.

                                       {
    return OFFSET_OF(UntaggedTypeArguments, nullability_);
  }

◆ Prepend()

TypeArgumentsPtr dart::TypeArguments::Prepend	(	Zone *	zone,
		const TypeArguments &	other,
		intptr_t	other_length,
		intptr_t	total_length
	)		const

Definition at line 6858 of file object.cc.

                                                                     {
  if (other_length == 0) {
    ASSERT(IsCanonical());
    return ptr();
  } else if (other_length == total_length) {
    ASSERT(other.IsCanonical());
    return other.ptr();
  } else if (IsNull() && other.IsNull()) {
    return TypeArguments::null();
  }
  const TypeArguments& result =
      TypeArguments::Handle(zone, TypeArguments::New(total_length, Heap::kNew));
  AbstractType& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < other_length; i++) {
    type = other.IsNull() ? Type::DynamicType() : other.TypeAt(i);
    result.SetTypeAt(i, type);
  }
  for (intptr_t i = other_length; i < total_length; i++) {
    type = IsNull() ? Type::DynamicType() : TypeAt(i - other_length);
    result.SetTypeAt(i, type);
  }
  return result.Canonicalize(Thread::Current());
}

◆ PrintSubvectorName()

void dart::TypeArguments::PrintSubvectorName	(	intptr_t	from_index,
		intptr_t	len,
		NameVisibility	name_visibility,
		BaseTextBuffer *	printer
	)		const

Definition at line 6941 of file object.cc.

                                                                      {
  printer->AddString("<");
  AbstractType& type = AbstractType::Handle();
  for (intptr_t i = 0; i < len; i++) {
    if (from_index + i < Length()) {
      type = TypeAt(from_index + i);
      if (type.IsNull()) {
        printer->AddString("null");  // Unfinalized vector.
      } else {
        type.PrintName(name_visibility, printer);
      }
    } else {
      printer->AddString("dynamic");
    }
    if (i < len - 1) {
      printer->AddString(", ");
    }
  }
  printer->AddString(">");
}

◆ PrintTo()

void dart::TypeArguments::PrintTo ( BaseTextBuffer * printer ) const

Definition at line 6965 of file object.cc.

                                                        {
  buffer->AddString("TypeArguments: ");
  if (IsNull()) {
    return buffer->AddString("null");
  }
  buffer->Printf("(H%" Px ")", Smi::Value(untag()->hash()));
  auto& type_at = AbstractType::Handle();
  for (intptr_t i = 0; i < Length(); i++) {
    type_at = TypeAt(i);
    buffer->Printf(" [%s]", type_at.IsNull() ? "null" : type_at.ToCString());
  }
}

◆ SetTypeAt()

void dart::TypeArguments::SetTypeAt	(	intptr_t	index,
		const AbstractType &	value
	)		const

Definition at line 7381 of file object.cc.

                                                                             {
  ASSERT(!IsCanonical());
  ASSERT((index >= 0) && (index < Length()));
  return untag()->set_element(index, value.ptr());
}

◆ ToInstantiatorTypeArguments()

TypeArgumentsPtr dart::TypeArguments::ToInstantiatorTypeArguments	(	Thread *	thread,
		const Class &	cls
	)		const

Definition at line 7853 of file object.cc.

                            {
  if (IsNull()) {
    return ptr();
  }
  const intptr_t num_type_arguments = cls.NumTypeArguments();
  const intptr_t num_type_parameters = cls.NumTypeParameters(thread);
  ASSERT(Length() == num_type_parameters);
  if (num_type_arguments == num_type_parameters) {
    return ptr();
  }
  Zone* zone = thread->zone();
  const auto& args =
      TypeArguments::Handle(zone, TypeArguments::New(num_type_arguments));
  const intptr_t offset = num_type_arguments - num_type_parameters;
  auto& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < num_type_parameters; ++i) {
    type = TypeAt(i);
    args.SetTypeAt(offset + i, type);
  }
  return args.ptr();
}

◆ TruncatedTo()

TypeArgumentsPtr dart::TypeArguments::TruncatedTo ( intptr_t length ) const

Definition at line 7572 of file object.cc.

                                                                 {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const TypeArguments& result =
      TypeArguments::Handle(zone, TypeArguments::New(length));
  AbstractType& type = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < length; i++) {
    type = TypeAt(i);
    result.SetTypeAt(i, type);
  }
  return result.Canonicalize(thread);
}

◆ type_at_offset()

static intptr_t dart::TypeArguments::type_at_offset ( intptr_t index )

inlinestatic

Definition at line 8563 of file object.h.

                                                 {
    return types_offset() + index * kCompressedWordSize;
  }

◆ TypeAt()

AbstractTypePtr dart::TypeArguments::TypeAt ( intptr_t index ) const

Definition at line 7366 of file object.cc.

                                                          {
  ASSERT(!IsNull());
  ASSERT((index >= 0) && (index < Length()));
  return untag()->element(index);
}

◆ TypeAtNullSafe()

AbstractTypePtr dart::TypeArguments::TypeAtNullSafe ( intptr_t index ) const

Definition at line 7372 of file object.cc.

                                                                  {
  if (IsNull()) {
    // null vector represents infinite list of dynamics
    return Type::dynamic_type().ptr();
  }
  ASSERT((index >= 0) && (index < Length()));
  return TypeAt(index);
}

◆ types_offset()

static intptr_t dart::TypeArguments::types_offset ( )

inlinestatic

Definition at line 8560 of file object.h.

                                 {
    return OFFSET_OF_RETURNED_VALUE(UntaggedTypeArguments, types);
  }

◆ UpdateFunctionTypes()

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

Definition at line 7639 of file object.cc.

                                                      {
  Zone* zone = Thread::Current()->zone();
  TypeArguments* updated_args = nullptr;
  AbstractType& type = AbstractType::Handle(zone);
  AbstractType& updated = AbstractType::Handle(zone);
  for (intptr_t i = 0, n = Length(); i < n; ++i) {
    type = TypeAt(i);
    updated = type.UpdateFunctionTypes(num_parent_type_args_adjustment,
                                       num_free_fun_type_params, space,
                                       function_type_mapping);
    if (type.ptr() != updated.ptr()) {
      if (updated_args == nullptr) {
        updated_args =
            &TypeArguments::Handle(zone, TypeArguments::New(n, space));
        for (intptr_t j = 0; j < i; ++j) {
          type = TypeAt(j);
          updated_args->SetTypeAt(j, type);
        }
      }
    }
    if (updated_args != nullptr) {
      updated_args->SetTypeAt(i, updated);
    }
  }
  return (updated_args != nullptr) ? updated_args->ptr() : ptr();
}

◆ UserVisibleName()

StringPtr dart::TypeArguments::UserVisibleName ( ) const

Definition at line 6934 of file object.cc.

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

Friends And Related Symbol Documentation

◆ AbstractType

friend class AbstractType

friend

Definition at line 9013 of file object.h.

◆ Class

friend class Class

friend

Definition at line 9014 of file object.h.

◆ ClearTypeHashVisitor

friend class ClearTypeHashVisitor

friend

Definition at line 9015 of file object.h.

◆ Object

friend class Object

friend

Definition at line 9016 of file object.h.

Member Data Documentation

◆ kAllDynamicHash

constexpr intptr_t dart::TypeArguments::kAllDynamicHash = 1

staticconstexpr

Definition at line 8549 of file object.h.

◆ kBytesPerElement

constexpr intptr_t dart::TypeArguments::kBytesPerElement = kCompressedWordSize

staticconstexpr

Definition at line 8959 of file object.h.

◆ kLegacyBits

constexpr intptr_t dart::TypeArguments::kLegacyBits = 2

staticconstexpr

Definition at line 8597 of file object.h.

◆ kMaxElements

constexpr intptr_t dart::TypeArguments::kMaxElements = kSmiMax / kBytesPerElement

staticconstexpr

Definition at line 8960 of file object.h.

◆ kNonNullableBits

constexpr intptr_t dart::TypeArguments::kNonNullableBits = 0

staticconstexpr

Definition at line 8595 of file object.h.

◆ kNullabilityBitsPerType

constexpr intptr_t dart::TypeArguments::kNullabilityBitsPerType = 2

staticconstexpr

Definition at line 8592 of file object.h.

◆ kNullabilityMaxTypes

constexpr intptr_t dart::TypeArguments::kNullabilityMaxTypes

staticconstexpr

Initial value:

=

kSmiBits / kNullabilityBitsPerType

dart::TypeArguments::kNullabilityBitsPerType

static constexpr intptr_t kNullabilityBitsPerType

Definition object.h:8592

dart::kSmiBits

const intptr_t kSmiBits

Definition globals.h:24

Definition at line 8593 of file object.h.

◆ kNullableBits

constexpr intptr_t dart::TypeArguments::kNullableBits = 3

staticconstexpr

Definition at line 8596 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

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ Canonicalize()

◆ CanonicalizeHash()

◆ CanonicalizeLocked()

◆ CanShareFunctionTypeArguments()

◆ CanShareInstantiatorTypeArguments()

◆ ConcatenateTypeParameters()

◆ EnumerateURIs()

◆ Equals()

◆ FromInstanceTypeArguments()

◆ GetInstantiationMode()

◆ HasCount()

◆ Hash()

◆ hash_offset()

◆ HashForRange()

◆ HasInstantiations()

◆ InstanceSize() [1/2]

◆ InstanceSize() [2/2]

◆ InstantiateAndCanonicalizeFrom()

◆ InstantiateFrom()

◆ instantiations_offset()

◆ IsEquivalent()

◆ IsFinalized()

◆ IsInstantiated()

◆ IsRaw()

◆ IsRawWhenInstantiatedFromRaw()

◆ IsSubvectorEquivalent()

◆ IsSubvectorInstantiated()

◆ IsUninstantiatedIdentity()

◆ Length()

◆ length_offset()

◆ Name()

◆ New()

◆ nullability()

◆ nullability_offset()

◆ Prepend()

◆ PrintSubvectorName()

◆ PrintTo()

◆ SetTypeAt()

◆ ToInstantiatorTypeArguments()

◆ TruncatedTo()

◆ type_at_offset()

◆ TypeAt()

◆ TypeAtNullSafe()

◆ types_offset()

◆ UpdateFunctionTypes()

◆ UserVisibleName()

Friends And Related Symbol Documentation

◆ AbstractType

◆ Class

◆ ClearTypeHashVisitor

◆ Object

Member Data Documentation

◆ kAllDynamicHash

◆ kBytesPerElement

◆ kLegacyBits

◆ kMaxElements

◆ kNonNullableBits

◆ kNullabilityBitsPerType

◆ kNullabilityMaxTypes

◆ kNullableBits