Class PHPStan\Type\Accessory\AccessoryArrayListType

Returns all class names referenced anywhere in this type, recursively (including generic arguments, callable signatures, etc.).

Returns class names of the object types this type directly represents. Unlike getReferencedClasses(), excludes classes in generic arguments, etc.

Only ConstantArrayType instances (array shapes with known keys).

Unlike isSuperTypeOf(), accepts() takes into account PHP's implicit type coercion. With $strictTypes = false, int is accepted by float, and Stringable objects are accepted by string.

"Does every value of $type belong to $this type?" Preferable to instanceof checks because it correctly handles union types, intersection types, and all other composite types.

Answers "is this compound type a subtype of $otherType?" from the compound type's perspective. Called by simple types when they encounter a CompoundType argument in their isSuperTypeOf() method. The compound type decomposes itself and calls $otherType->isSuperTypeOf() for each component. For example, UnionType(string|int)::isSubTypeOf(MixedType) asks MixedType whether it is a supertype of string and int separately, then combines with extremeIdentity (all must pass).

Answers "is this compound type accepted by $acceptingType?" from the compound type's perspective. Called by simple types when they encounter a CompoundType argument in their accepts() method. The compound type decomposes itself and calls $acceptingType->accepts() for each component. For example, UnionType(string|int)::isAcceptedBy(StringType) asks StringType to accept string and int separately, then combines results with extremeIdentity (all must pass).

Whether accessing a non-existent offset is safe (won't cause errors). Unlike isOffsetAccessible() which checks if offset access is supported at all.

May add a new key. When $offsetType is null, appends (like $a[] = $value).

Unlike setOffsetValueType(), assumes the key already exists. Preserves the array shape and list type.

Models array_keys($array, $searchValue, $strict).

Models array_keys($array).

Models array_values($array).

Models array_chunk($array, $length, $preserveKeys).

Models array_fill_keys($keys, $value).

Models array_flip($array).

Models array_intersect_key($array, ...$otherArrays).

Models array_pop() effect on the array.

Models array_reverse($array, $preserveKeys).

Models array_search($needle, $array, $strict).

Models array_shift() effect on the array.

Models shuffle() effect on the array. Result is always a list. It's also used to model array after sort / rsort / usort calls.

Models array_slice($array, $offset, $length, $preserveKeys).

Models array_splice() effect on the array (the modified array, not the removed portion).

Downgrades the list-ness of the array from Yes to Maybe (e.g. for asort/uksort/etc. which preserve keys but break list ordering). Other shape information (keys, values, accessories like NonEmpty) is preserved.

Models "same keys, every value transformed" (e.g. array_walk, array_map($cb, $a), preg_replace* over an array subject). Keys and accessories like list-ness / non-emptiness are preserved.

Replaces the iterable key type via $cb($currentKeyType). For ArrayType rewrites the key type wholesale; for ConstantArrayType the explicit keys (which are already precise constants) are preserved — pass-through, matching the prior TypeTraverser-based callers. Used to widen / narrow the key type after a foreach narrowed $key via is_int($key) / is_string($key) checks.

Marks every explicit key in a ConstantArrayType as optional (the shape can have any subset of the original keys). For non-CAT arrays this is a no-op — they already model arbitrary subsets. Used by preg_replace* over array subjects, where the callback can drop entries.

Models array_change_key_case($a, $case). String keys are case-folded (constant ones to a specific value, general ones via accessories); non-string keys, values, accessories and list-ness are preserved. $case matches PHP's CASE_LOWER / CASE_UPPER; null means the case is non-constant and the result is the union of both folds.

Models array_filter($a) (no callback): drops entries whose value is definitely falsey, marks possibly-falsey entries optional, keeps definitely-truthy entries unchanged. Keys are preserved; list-ness is downgraded since gaps may appear.

Returns the count of elements as a Type (typically IntegerRangeType).

Works for both arrays and Traversable objects.

An oversized array is a constant array shape that grew too large to track precisely and was degraded to a generic array type.

A list is an array with sequential integer keys starting from 0 with no gaps.

Is Type of a known constant value? Includes literal strings, integers, floats, true, false, null, and array shapes. Unlike isConstantScalarValue(), this also returns yes for constant array types (array shapes with known keys and values). Use this when you need to detect any constant value including arrays.

Is Type of a known constant scalar value? Includes literal strings, integers, floats, true, false, and null. Unlike isConstantValue(), this does NOT return yes for array shapes. Use this when you specifically need scalar constants only.

When isDecimalIntegerString() returns yes(), the type is guaranteed to be cast to an integer in an array key. Examples of constant values covered by this type: "0", "1", "1234", "-1" When isDecimalIntegerString() returns no(), the type represents strings containing non-decimal integers and other text. These are guaranteed to stay as string in an array key. Examples of constant values covered by this type: "+1", "00", "18E+3", "1.2", "1,3", "foo"

Non-falsy string is a non-empty string that is also not '0'. Stricter subset of non-empty-string.

A literal-string is a string composed entirely from string literals in the source code (not from user input). Used for SQL injection prevention.

Returns the object type for a class-string or literal class name string. For non-class-string types, returns ErrorType.

Like getClassStringObjectType(), but also returns object types as-is. Used for $classOrObject::method() where the left side can be either.

Models numeric coercion for arithmetic operators.

Models the bitwise-not (~$x) operator. Returns ErrorType for types where ~ is undefined.

Models abs().

Models the (int) cast.

Models the (float) cast.

Models the (string) cast.

Models the (array) cast.

Models PHP's implicit array key coercion: floats truncated to int, booleans become 0/1, null becomes '', numeric strings become int.

Returns how this type might change when passed to a typed parameter or assigned to a typed property. With $strictTypes = true: int widens to int|float (since int is accepted by float parameters in strict mode). With $strictTypes = false: additional coercions apply, e.g. Stringable objects are accepted by string parameters. Used internally to determine what types a value might be coerced to when checking parameter acceptance.

Returns a new instance with all inner types mapped through $cb. Returns the same instance if inner types did not change. Not used directly — use TypeTraverser::map() instead.

Like traverse(), but walks two types simultaneously. Not used directly — use SimultaneousTypeTraverser::map() instead.

Models the ** operator.

Returns a list of finite values this type can take. Examples: - for bool: [true, false]

• for int<0, 3>: [0, 1, 2, 3]
• for enums: list of enum cases
• for scalars: the scalar itself For infinite types it returns an empty array.

Performance optimization to skip template resolution when no templates are present.