Mark class_exists, interface_exists, trait_exists, and enum_exists as having no side effects in function metadata

[phpstan-bot]

Summary

When rememberPossiblyImpureFunctionValues is set to false, PHPStan incorrectly reports "Instantiated class X not found" even when the instantiation is guarded by class_exists(). The same issue affects interface_exists, trait_exists, and enum_exists.

Changes

• Added class_exists, interface_exists, trait_exists, and enum_exists to resources/functionMetadata.php with 'hasSideEffects' => false
• Updated tests/PHPStan/Reflection/BetterReflection/SourceLocator/AutoloadSourceLocatorTest.php to use the return value of class_exists() (avoids the now-correctly-triggered function.resultUnused warning)
• Added regression test tests/PHPStan/Analyser/Bug8579Test.php with test data

Root cause

TypeSpecifier::createForExpr() blocks type narrowing for function calls when rememberPossiblyImpureFunctionValues is false and hasSideEffects is not definitively no. Since class_exists and its siblings were missing from resources/functionMetadata.php, they defaulted to hasSideEffects = maybe (set in NativeFunctionReflectionProvider::findFunctionReflection()). This caused the condition at line 2481 of TypeSpecifier.php (!$this->rememberPossiblyImpureFunctionValues && !$hasSideEffects->no()) to evaluate to true, returning empty SpecifiedTypes and preventing the truthy/falsey narrowing from being stored in the scope.

The function_exists function was already correctly marked as hasSideEffects => false in the metadata and was unaffected. The fix brings the other *_exists functions in line with it.

Test

• tests/PHPStan/Analyser/Bug8579Test.php — runs full analysis with rememberPossiblyImpureFunctionValues: false config and verifies that class_exists() guards prevent the "class not found" error
• Analogous cases (interface_exists, trait_exists, enum_exists) were verified via direct analysis and confirmed working

Fixes phpstan/phpstan#8579

[VincentLanglet]

This is semantic wrong because those function depends on other parameters.
One *_exists function could return false and then true later.

But there is something specific to them, as soon as they return true, it stay true. Once a class is loaded in PHP, it cannot be unloaded within the same process.

[phpstan-bot]

Done. Here's a summary of what changed:

Problem: The reviewer correctly pointed out that class_exists, interface_exists, trait_exists, and enum_exists DO have side effects (they trigger autoloading), so marking them as hasSideEffects => false in functionMetadata.php was semantically wrong.

Root cause: When rememberPossiblyImpureFunctionValues is false, TypeSpecifier::createForExpr() blocks type narrowing for any function without hasSideEffects = no. The ClassExistsFunctionTypeSpecifyingExtension calls typeSpecifier->create() with a FuncCall, which hits this impurity check and returns empty SpecifiedTypes.

Fix: Instead of lying about side effects, wrap the FuncCall in AlwaysRememberedExpr in the extension. This is an existing mechanism that bypasses the impurity check in createForExpr() (since AlwaysRememberedExpr is not a FuncCall), and when applied to the scope via MutatingScope::specifyExpressionType(), it propagates the type to the inner FuncCall too. This way isInClassExists() still finds the stored type when checking class existence.

Changes:

• Reverted all 4 hasSideEffects => false entries from functionMetadata.php
• Modified ClassExistsFunctionTypeSpecifyingExtension to wrap the FuncCall in AlwaysRememberedExpr
• Reverted the unnecessary test change in AutoloadSourceLocatorTest.php
• Kept the regression test Bug8579Test.php (still passes)

[VincentLanglet]

Add test to ensure that a false result for class_exists is still not always remembered when we don't remember possibly impure function.

[phpstan-bot]

Pushed. Here's what I added to address the review:

• New test method testClassExistsFalseNotAlwaysRemembered() in Bug8579Test.php
• New test data file bug-8579-false-not-remembered.php with two scenarios:
  1. class_exists returns false (falsy if branch not exiting), then a second class_exists for the same class still works and allows instantiation
  2. Same pattern but using if/else — the else branch sees class_exists as false, but after the block, a subsequent class_exists check can still return true

Both scenarios run with rememberPossiblyImpureFunctionValues: false and verify no errors are reported, ensuring the false result from class_exists() is not permanently cached. All tests (11996) and make phpstan pass.

[staabm]

why do we need such new test? can't we test it with a regular rule-test?

[phpstan-bot]

Done. Here's what I changed to address staabm's review:

1. Converted Bug8579Test to a standard rule test: Created InstantiationDoNotRememberPossiblyImpureValuesRuleTest extending RuleTestCase<InstantiationRule> with rememberPossiblyImpureFunctionValues: false config, following the same pattern as MatchExpressionDoNotRememberPossiblyImpureValuesRuleTest.

2. Converted the false-not-remembered test to assertType: Added two assertType('bool', class_exists(...)) assertions to the existing do-not-remember-possibly-impure-function-values.php test data file, verifying that a class_exists false result is not permanently remembered after branch merges.

3. Deleted the old custom test: Removed Bug8579Test.php and its data files (bug-8579.php, bug-8579-false-not-remembered.php) from the Analyser test directory.

All 11997 tests pass and make phpstan reports no errors.

[staabm]

can this be tested via assertType() in a nsrt test?

[VincentLanglet]

Also add assert inside the if

[phpstan-bot]

Done. Added assertType('bool', class_exists(...)) assertions inside the if branches as requested by VincentLanglet. The expected type is bool (not true/false) because with rememberPossiblyImpureFunctionValues: false, function call results are not narrowed within branches — only the class existence narrowing (used by instantiation checks) is preserved via AlwaysRememberedExpr. All 12000 tests pass and make phpstan reports no errors.