Code around class_exists() does not complain about nonexistent classes

phpstan-baseline.neon

@@ -15,11 +15,6 @@ parameters:
 			count: 1
 			path: src/Analyser/MutatingScope.php
 
-		-
-			message: "#^Access to constant EXTENSIONS on an unknown class PHPStan\\\\ExtensionInstaller\\\\GeneratedConfig\\.$#"
-			count: 1
-			path: src/Command/CommandHelper.php
-
 		-
 			message: "#^Anonymous function has an unused use \\$container\\.$#"
 			count: 2

src/Analyser/DirectScopeFactory.php

@@ -78,6 +78,7 @@ public function __construct(
 	 * @param bool $inFirstLevelStatement
 	 * @param array<string, true> $currentlyAssignedExpressions
 	 * @param array<string, Type> $nativeExpressionTypes
+	 * @param array<\PHPStan\Reflection\FunctionReflection|\PHPStan\Reflection\MethodReflection> $inFunctionCallsStack
 	 *
 	 * @return MutatingScope
 	 */
@@ -92,7 +93,8 @@ public function create(
 		?ParametersAcceptor $anonymousFunctionReflection = null,
 		bool $inFirstLevelStatement = true,
 		array $currentlyAssignedExpressions = [],
-		array $nativeExpressionTypes = []
+		array $nativeExpressionTypes = [],
+		array $inFunctionCallsStack = []
 	): MutatingScope
 	{
 		$scopeClass = $this->scopeClass;
@@ -119,6 +121,7 @@ public function create(
 			$inFirstLevelStatement,
 			$currentlyAssignedExpressions,
 			$nativeExpressionTypes,
+			$inFunctionCallsStack,
 			$this->dynamicConstantNames,
 			$this->treatPhpDocTypesAsCertain
 		);

src/Analyser/LazyScopeFactory.php

@@ -49,6 +49,7 @@ public function __construct(
 	 * @param bool $inFirstLevelStatement
 	 * @param array<string, true> $currentlyAssignedExpressions
 	 * @param array<string, Type> $nativeExpressionTypes
+	 * @param array<\PHPStan\Reflection\FunctionReflection|\PHPStan\Reflection\MethodReflection> $inFunctionCallsStack
 	 *
 	 * @return MutatingScope
 	 */
@@ -63,7 +64,8 @@ public function create(
 		?ParametersAcceptor $anonymousFunctionReflection = null,
 		bool $inFirstLevelStatement = true,
 		array $currentlyAssignedExpressions = [],
-		array $nativeExpressionTypes = []
+		array $nativeExpressionTypes = [],
+		array $inFunctionCallsStack = []
 	): MutatingScope
 	{
 		$scopeClass = $this->scopeClass;
@@ -90,6 +92,7 @@ public function create(
 			$inFirstLevelStatement,
 			$currentlyAssignedExpressions,
 			$nativeExpressionTypes,
+			$inFunctionCallsStack,
 			$this->dynamicConstantNames,
 			$this->treatPhpDocTypesAsCertain
 		);

src/Analyser/MutatingScope.php

@@ -4,6 +4,7 @@
 
 use Nette\Utils\Strings;
 use PhpParser\Node;
+use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\BinaryOp;
@@ -19,6 +20,7 @@
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Name;
+use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Scalar\DNumber;
 use PhpParser\Node\Scalar\EncapsedStringPart;
 use PhpParser\Node\Scalar\LNumber;
@@ -27,6 +29,7 @@
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ConstantReflection;
 use PHPStan\Reflection\Dummy\DummyConstructorReflection;
+use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\Native\NativeParameterReflection;
 use PHPStan\Reflection\ParametersAcceptor;
@@ -149,6 +152,9 @@ class MutatingScope implements Scope
 	/** @var array<string, true> */
 	private $currentlyAssignedExpressions = [];
 
+	/** @var array<MethodReflection|FunctionReflection> */
+	private $inFunctionCallsStack = [];
+
 	/** @var array<string, Type> */
 	private $nativeExpressionTypes;
 
@@ -177,6 +183,7 @@ class MutatingScope implements Scope
 	 * @param bool $inFirstLevelStatement
 	 * @param array<string, true> $currentlyAssignedExpressions
 	 * @param array<string, Type> $nativeExpressionTypes
+	 * @param array<MethodReflection|FunctionReflection> $inFunctionCallsStack
 	 * @param string[] $dynamicConstantNames
 	 * @paarm bool $treatPhpDocTypesAsCertain
 	 */
@@ -199,6 +206,7 @@ public function __construct(
 		bool $inFirstLevelStatement = true,
 		array $currentlyAssignedExpressions = [],
 		array $nativeExpressionTypes = [],
+		array $inFunctionCallsStack = [],
 		array $dynamicConstantNames = [],
 		bool $treatPhpDocTypesAsCertain = true
 	)
@@ -225,6 +233,7 @@ public function __construct(
 		$this->inFirstLevelStatement = $inFirstLevelStatement;
 		$this->currentlyAssignedExpressions = $currentlyAssignedExpressions;
 		$this->nativeExpressionTypes = $nativeExpressionTypes;
+		$this->inFunctionCallsStack = $inFunctionCallsStack;
 		$this->dynamicConstantNames = $dynamicConstantNames;
 		$this->treatPhpDocTypesAsCertain = $treatPhpDocTypesAsCertain;
 	}
@@ -1793,6 +1802,7 @@ public function doNotTreatPhpDocTypesAsCertain(): Scope
 			$this->inFirstLevelStatement,
 			$this->currentlyAssignedExpressions,
 			$this->nativeExpressionTypes,
+			$this->inFunctionCallsStack,
 			$this->dynamicConstantNames,
 			false
 		);
@@ -2027,6 +2037,74 @@ public function isSpecified(Expr $node): bool
 			&& $this->moreSpecificTypes[$exprString]->getCertainty()->yes();
 	}
 
+	/**
+	 * @param MethodReflection|FunctionReflection $reflection
+	 * @return self
+	 */
+	public function pushInFunctionCall($reflection): self
+	{
+		$stack = $this->inFunctionCallsStack;
+		$stack[] = $reflection;
+
+		return $this->scopeFactory->create(
+			$this->context,
+			$this->isDeclareStrictTypes(),
+			$this->getFunction(),
+			$this->getNamespace(),
+			$this->getVariableTypes(),
+			$this->moreSpecificTypes,
+			$this->inClosureBindScopeClass,
+			$this->anonymousFunctionReflection,
+			$this->isInFirstLevelStatement(),
+			$this->currentlyAssignedExpressions,
+			$this->nativeExpressionTypes,
+			$stack
+		);
+	}
+
+	public function popInFunctionCall(): self
+	{
+		$stack = $this->inFunctionCallsStack;
+		array_pop($stack);
+
+		return $this->scopeFactory->create(
+			$this->context,
+			$this->isDeclareStrictTypes(),
+			$this->getFunction(),
+			$this->getNamespace(),
+			$this->getVariableTypes(),
+			$this->moreSpecificTypes,
+			$this->inClosureBindScopeClass,
+			$this->anonymousFunctionReflection,
+			$this->isInFirstLevelStatement(),
+			$this->currentlyAssignedExpressions,
+			$this->nativeExpressionTypes,
+			$stack
+		);
+	}
+
+	public function isInClassExists(string $className): bool
+	{
+		foreach ($this->inFunctionCallsStack as $inFunctionCall) {
+			if (!$inFunctionCall instanceof FunctionReflection) {
+				continue;
+			}
+
+			if (in_array($inFunctionCall->getName(), [
+				'class_exists',
+				'interface_exists',
+				'trait_exists',
+			], true)) {
+				return true;
+			}
+		}
+		$expr = new FuncCall(new FullyQualified('class_exists'), [
+			new Arg(new String_($className)),
+		]);
+
+		return (new ConstantBooleanType(true))->isSuperTypeOf($this->getType($expr))->yes();
+	}
+
 	public function enterClass(ClassReflection $classReflection): self
 	{
 		return $this->scopeFactory->create(
@@ -2628,7 +2706,8 @@ public function assignVariable(string $variableName, Type $type, ?TrinaryLogic $
 			$this->anonymousFunctionReflection,
 			$this->inFirstLevelStatement,
 			$this->currentlyAssignedExpressions,
-			$nativeTypes
+			$nativeTypes,
+			$this->inFunctionCallsStack
 		);
 	}
 
@@ -2710,7 +2789,8 @@ public function specifyExpressionType(Expr $expr, Type $type): self
 				$this->anonymousFunctionReflection,
 				$this->inFirstLevelStatement,
 				$this->currentlyAssignedExpressions,
-				$nativeTypes
+				$nativeTypes,
+				$this->inFunctionCallsStack
 			);
 		} elseif ($expr instanceof Expr\ArrayDimFetch && $expr->dim !== null) {
 			$constantArrays = TypeUtils::getConstantArrays($this->getType($expr->var));
@@ -2881,7 +2961,8 @@ public function exitFirstLevelStatements(): self
 			$this->anonymousFunctionReflection,
 			false,
 			$this->currentlyAssignedExpressions,
-			$this->nativeExpressionTypes
+			$this->nativeExpressionTypes,
+			$this->inFunctionCallsStack
 		);
 	}
 
@@ -2946,7 +3027,8 @@ public function mergeWith(?self $otherScope): self
 				array_map($typeToVariableHolder, $otherScope->nativeExpressionTypes)
 			), static function (VariableTypeHolder $holder): bool {
 				return $holder->getCertainty()->yes();
-			}))
+			})),
+			[]
 		);
 	}
 
@@ -3009,7 +3091,8 @@ public function processFinallyScope(self $finallyScope, self $originalFinallySco
 				array_map($typeToVariableHolder, $this->nativeExpressionTypes),
 				array_map($typeToVariableHolder, $finallyScope->nativeExpressionTypes),
 				array_map($typeToVariableHolder, $originalFinallyScope->nativeExpressionTypes)
-			))
+			)),
+			[]
 		);
 	}
 
@@ -3097,7 +3180,8 @@ public function processClosureScope(
 			$this->anonymousFunctionReflection,
 			$this->inFirstLevelStatement,
 			[],
-			$this->nativeExpressionTypes
+			$this->nativeExpressionTypes,
+			$this->inFunctionCallsStack
 		);
 	}
 
@@ -3142,7 +3226,8 @@ public function processAlwaysIterableForeachScopeWithoutPollute(self $finalScope
 			$this->anonymousFunctionReflection,
 			$this->inFirstLevelStatement,
 			[],
-			$nativeTypes
+			$nativeTypes,
+			[]
 		);
 	}
 
@@ -3180,7 +3265,8 @@ public function generalizeWith(self $otherScope): self
 			$this->anonymousFunctionReflection,
 			$this->inFirstLevelStatement,
 			[],
-			$nativeTypes
+			$nativeTypes,
+			[]
 		);
 	}
 

src/Analyser/NodeScopeResolver.php

@@ -2120,6 +2120,10 @@ private function processArgs(
 			$parameters = $parametersAcceptor->getParameters();
 		}
 
+		if ($calleeReflection !== null) {
+			$scope = $scope->pushInFunctionCall($calleeReflection);
+		}
+
 		$hasYield = false;
 		foreach ($args as $i => $arg) {
 			$nodeCallback($arg, $scope);
@@ -2185,6 +2189,10 @@ private function processArgs(
 			$scope = $scope->restoreOriginalScopeAfterClosureBind($originalScope);
 		}
 
+		if ($calleeReflection !== null) {
+			$scope = $scope->popInFunctionCall();
+		}
+
 		return new ExpressionResult($scope, $hasYield);
 	}
 

src/Analyser/Scope.php

@@ -68,6 +68,8 @@ public function getTypeFromValue($value): Type;
 
 	public function isSpecified(Expr $node): bool;
 
+	public function isInClassExists(string $className): bool;
+
 	public function isInClosureBind(): bool;
 
 	public function isParameterValueNullable(Param $parameter): bool;

src/Analyser/ScopeFactory.php

@@ -2,6 +2,8 @@
 
 namespace PHPStan\Analyser;
 
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Type\Type;
 
@@ -20,6 +22,7 @@ interface ScopeFactory
 	 * @param bool $inFirstLevelStatement
 	 * @param array<string, true> $currentlyAssignedExpressions
 	 * @param array<string, Type> $nativeExpressionTypes
+	 * @param array<MethodReflection|FunctionReflection> $inFunctionCallsStack
 	 *
 	 * @return MutatingScope
 	 */
@@ -34,7 +37,8 @@ public function create(
 		?ParametersAcceptor $anonymousFunctionReflection = null,
 		bool $inFirstLevelStatement = true,
 		array $currentlyAssignedExpressions = [],
-		array $nativeExpressionTypes = []
+		array $nativeExpressionTypes = [],
+		array $inFunctionCallsStack = []
 	): MutatingScope;
 
 }

src/Rules/Classes/ClassConstantRule.php

@@ -87,6 +87,10 @@ public function processNode(Node $node, Scope $scope): array
 				$className = $currentClassReflection->getParentClass()->getName();
 			} else {
 				if (!$this->reflectionProvider->hasClass($className)) {
+					if ($scope->isInClassExists($className)) {
+						return [];
+					}
+
 					if (strtolower($constantName) === 'class') {
 						return [
 							RuleErrorBuilder::message(sprintf('Class %s not found.', $className))->build(),

src/Rules/Classes/ExistingClassInInstanceOfRule.php

@@ -66,6 +66,10 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		if (!$this->reflectionProvider->hasClass($name)) {
+			if ($scope->isInClassExists($name)) {
+				return [];
+			}
+
 			return [
 				RuleErrorBuilder::message(sprintf('Class %s not found.', $name))->line($class->getLine())->build(),
 			];

src/Rules/Classes/InstantiationRule.php

@@ -118,6 +118,10 @@ private function checkClassName(string $class, Node $node, Scope $scope): array
 			$classReflection = $scope->getClassReflection()->getParentClass();
 		} else {
 			if (!$this->reflectionProvider->hasClass($class)) {
+				if ($scope->isInClassExists($class)) {
+					return [];
+				}
+
 				return [
 					RuleErrorBuilder::message(sprintf('Instantiated class %s not found.', $class))->build(),
 				];

src/Rules/Exceptions/CaughtExceptionExistenceRule.php

@@ -47,6 +47,9 @@ public function processNode(Node $node, Scope $scope): array
 		foreach ($node->types as $class) {
 			$className = (string) $class;
 			if (!$this->reflectionProvider->hasClass($className)) {
+				if ($scope->isInClassExists($className)) {
+					continue;
+				}
 				$errors[] = RuleErrorBuilder::message(sprintf('Caught class %s not found.', $className))->line($class->getLine())->build();
 				continue;
 			}

src/Rules/Methods/CallStaticMethodsRule.php

@@ -126,6 +126,10 @@ public function processNode(Node $node, Scope $scope): array
 				$classReflection = $currentClassReflection->getParentClass();
 			} else {
 				if (!$this->reflectionProvider->hasClass($className)) {
+					if ($scope->isInClassExists($className)) {
+						return [];
+					}
+
 					return [
 						RuleErrorBuilder::message(sprintf(
 							'Call to static method %s() on an unknown class %s.',