Class PHPStan\Type\Constant\ConstantArrayType

Only ConstantArrayType instances (array shapes with known keys).

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

Works for both arrays and Traversable objects.

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.

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.

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.

Removes or marks as optional the key(s) matching the given offset type from this constant array. By default, the method assumes an actual unset() call was made, which actively modifies the array and weakens its list certainty to "maybe". However, in some contexts, such as the else branch of an array_key_exists() check, the key is statically known to be absent without any modification, so list certainty should be preserved as-is.

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).

Narrows a list-shaped array type to "size lies in $sizeType" — the type-system equivalent of count($list) === N / count($list) >= N / count($list) in [N, M]. Used by TypeSpecifier when specifying types for count() comparisons; the call site is responsible for gating on outer list-ness, so each implementation may assume it's narrowing a list shape. $sizeType is expected to be a ConstantIntegerType (exact size) or an IntegerRangeType (a min/max bound). Concrete implementations (ConstantArrayType, ArrayType) rebuild the array with a required prefix [0, min) and an optional middle [min, max) (when max is set), or extend with HasOffsetValueType accessories when the upper bound is unbounded. Non-array types return ErrorType.

Extracts (min, max) bounds from a size type for truncateListToSize. ConstantIntegerType(N) → [N, N]. IntegerRangeType → [$min, $max]. Anything else returns [null, null] and the caller falls back to the non-precise path.

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

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

Models the (bool) cast.

Models the (int) cast.

Models the (float) cast.

Removes constant value information. E.g. 'foo' -> string, 1 -> int. Used when types become too complex to track precisely (e.g. loop iterations).

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

Models array_keys($array).

Models array_values($array).

Infers the real types of TemplateTypes found in $this, based on the received Type. E.g. if $this is array<T> and $receivedType is array, infers T = int.

Returns the template types referenced by this Type, recursively. The return value is a list of TemplateTypeReferences, who contain the referenced template type as well as the variance position in which it was found. For example, calling this on array<Foo<T>,Bar> (with T a template type) will return one TemplateTypeReference for the type T.

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.

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 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.