Widen empty ConstantArrayType to array when resolving dynamic constant types

[phpstan-bot]

Summary

When a constant is defined as an empty array (define('FOO', []) or const FOO = []) and listed in dynamicConstantNames, PHPStan should treat its type as array (non-constant). Instead, the type remained array{}, causing false positives like "Offset 'X' on array{} in isset() does not exist."

Changes

• Added generalizeDynamicConstantType() helper method in src/Analyser/ConstantResolver.php that handles the case where generalize(lessSpecific) fails to widen the type (returns a type still satisfying isConstantValue()->yes())
• Updated resolveConstantType() and resolveClassConstantType() to use the new helper
• Added test cases for global dynamic empty array constants and class dynamic empty array constants in tests/PHPStan/Analyser/data/dynamic-constant.php and tests/PHPStan/Analyser/dynamic-constants.neon

Analogous cases probed

• Class constants with empty arrays (no PHPDoc): Same root cause, fixed by the same resolveClassConstantType() change. Test added.
• Class constants with PHPDoc types: Already correctly handled — resolveClassConstantType() uses the PHPDoc type before reaching generalize(). Existing test confirms (DYNAMIC_EMPTY_ARRAY_WITH_PHPDOC_CONSTANT).
• Other scalar constant types (bool, int, string, float): Already correctly generalized — generalize(lessSpecific) widens true→bool, 42→int, etc. No fix needed.
• NullType: generalize() returns null (itself), but null has no wider type, so this is correct. Users needing a wider type should use the explicit type syntax (FOO: 'string|null').
• Non-empty ConstantArrayType: Already correctly generalized to ArrayType with generalized key/value types. No fix needed.

Root cause

ConstantArrayType::generalize(GeneralizePrecision::lessSpecific()) has an early return for empty arrays (count($this->keyTypes) === 0 → return $this). This means an empty constant array "generalizes" to itself — still a constant value. When ConstantResolver::resolveConstantType() calls generalize() to widen a dynamic constant's type, the empty array passes through unchanged.

Rather than changing generalize() globally (which would affect type descriptions in error messages, making unions like array{}|array{a: int} describe as array instead of array<string, int>), the fix is scoped to ConstantResolver: after calling generalize(), if the result is still a constant array value, fall back to ArrayType(MixedType, MixedType).

Test

• Type inference test: Added assertType('array', GLOBAL_DYNAMIC_EMPTY_ARRAY) and assertType('array', DynamicConstantClass::DYNAMIC_EMPTY_ARRAY_NO_PHPDOC) in tests/PHPStan/Analyser/data/dynamic-constant.php. Both fail without the fix (actual type: array{}), pass with it.

Fixes phpstan/phpstan#8526

[VincentLanglet]

I don't think you really understood the issue.

Let's start with a (possibly failing test).

Use

dynamicConstantNames:
        - FOO
        - DYNAMICARRAY

with

define('FOO', true);
define('DYNAMICARRAY', []);

if (isset(DYNAMICARRAY['MyKey'])){
..
}
if (FOO) {
    echo 'foo';
}

and ensure that there is no

• Offset 'MyKey' on array{} in isset() does not exist.
• If condition is always true

errors

[phpstan-bot]

Done. Added an integration test (Bug8526IntegrationTest) that directly verifies the reviewer's requested scenario:

• define('FOO', true) + define('DYNAMICARRAY', []) with dynamicConstantNames: [FOO, DYNAMICARRAY]
• if (isset(DYNAMICARRAY['MyKey'])) must not produce "Offset 'MyKey' on array{} in isset() does not exist"
• if (FOO) must not produce "If condition is always true"

I verified the test fails without the fix (showing the "Offset 'MyKey' on array{} in isset() does not exist" error) and passes with the fix. All existing tests and make phpstan pass cleanly.