Bleeding edge - RuntimeReflectionFunctionRule

conf/bleedingEdge.neon

@@ -16,3 +16,4 @@ parameters:
 		checkUnresolvableParameterTypes: true
 		readOnlyByPhpDoc: true
 		phpDocParserRequireWhitespaceBeforeDescription: true
+		runtimeReflectionRules: true

conf/config.level0.neon

@@ -12,6 +12,8 @@ conditionalTags:
 		phpstan.rules.rule: %checkUninitializedProperties%
 	PHPStan\Rules\Methods\ConsistentConstructorRule:
 		phpstan.rules.rule: %featureToggles.consistentConstructor%
+	PHPStan\Rules\Api\RuntimeReflectionFunctionRule:
+		phpstan.rules.rule: %featureToggles.runtimeReflectionRules%
 
 rules:
 	- PHPStan\Rules\Api\ApiInstantiationRule
@@ -78,6 +80,8 @@ rules:
 services:
 	-
 		class: PHPStan\Rules\Api\NodeConnectingVisitorAttributesRule
+	-
+		class: PHPStan\Rules\Api\RuntimeReflectionFunctionRule
 	-
 		class: PHPStan\Rules\Classes\ExistingClassInClassExtendsRule
 		tags:

conf/config.neon

@@ -41,6 +41,7 @@ parameters:
 		checkUnresolvableParameterTypes: false
 		readOnlyByPhpDoc: false
 		phpDocParserRequireWhitespaceBeforeDescription: false
+		runtimeReflectionRules: false
 	fileExtensions:
 		- php
 	checkAdvancedIsset: false
@@ -243,6 +244,7 @@ parametersSchema:
 		checkUnresolvableParameterTypes: bool()
 		readOnlyByPhpDoc: bool()
 		phpDocParserRequireWhitespaceBeforeDescription: bool()
+		runtimeReflectionRules: bool()
 	])
 	fileExtensions: listOf(string())
 	checkAdvancedIsset: bool()

phpstan-baseline.neon

@@ -1,5 +1,15 @@
 parameters:
 	ignoreErrors:
+		-
+			message: "#^Function is_a\\(\\) is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine\\. Use objects retrieved from ReflectionProvider instead\\.$#"
+			count: 1
+			path: src/Analyser/DirectScopeFactory.php
+
+		-
+			message: "#^Function is_a\\(\\) is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine\\. Use objects retrieved from ReflectionProvider instead\\.$#"
+			count: 1
+			path: src/Analyser/LazyScopeFactory.php
+
 		-
 			message: """
 				#^Call to deprecated method getTypeFromValue\\(\\) of class PHPStan\\\\Type\\\\ConstantTypeHelper\\:

src/Rules/Api/RuntimeReflectionFunctionRule.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Api;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function array_keys;
+use function in_array;
+use function sprintf;
+use function strpos;
+
+/**
+ * @implements Rule<Node\Expr\FuncCall>
+ */
+class RuntimeReflectionFunctionRule implements Rule
+{
+
+	public function __construct(private ReflectionProvider $reflectionProvider)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return Node\Expr\FuncCall::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (!$node->name instanceof Node\Name) {
+			return [];
+		}
+
+		if (!$this->reflectionProvider->hasFunction($node->name, $scope)) {
+			return [];
+		}
+
+		$functionReflection = $this->reflectionProvider->getFunction($node->name, $scope);
+		if (!in_array($functionReflection->getName(), [
+			'is_a',
+			'is_subclass_of',
+			'class_parents',
+			'class_implements',
+			'class_uses',
+		], true)) {
+			return [];
+		}
+
+		if (!$scope->isInClass()) {
+			return [];
+		}
+
+		$classReflection = $scope->getClassReflection();
+		$hasPhpStanInterface = false;
+		foreach (array_keys($classReflection->getInterfaces()) as $interfaceName) {
+			if (strpos($interfaceName, 'PHPStan\\') !== 0) {
+				continue;
+			}
+
+			$hasPhpStanInterface = true;
+		}
+
+		if (!$hasPhpStanInterface) {
+			return [];
+		}
+
+		return [
+			RuleErrorBuilder::message(
+				sprintf('Function %s() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.', $functionReflection->getName()),
+			)->build(),
+		];
+	}
+
+}

tests/PHPStan/Rules/Api/RuntimeReflectionFunctionRuleTest.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Api;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<RuntimeReflectionFunctionRule>
+ */
+class RuntimeReflectionFunctionRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new RuntimeReflectionFunctionRule($this->createReflectionProvider());
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/runtime-reflection-function.php'], [
+			[
+				'Function is_a() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.',
+				43,
+			],
+			[
+				'Function is_subclass_of() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.',
+				46,
+			],
+			[
+				'Function class_parents() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.',
+				49,
+			],
+			[
+				'Function class_implements() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.',
+				50,
+			],
+			[
+				'Function class_uses() is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine. Use objects retrieved from ReflectionProvider instead.',
+				51,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Api/data/runtime-reflection-function.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace RuntimeReflectionFunction;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Type;
+
+class Foo
+{
+
+	public function doFoo(object $o): void
+	{
+		if (is_a($o, \stdClass::class)) {
+
+		}
+	}
+
+}
+
+class Bar implements DynamicMethodReturnTypeExtension
+{
+
+	public function getClass(): string
+	{
+		// TODO: Implement getClass() method.
+	}
+
+	public function isMethodSupported(MethodReflection $methodReflection): bool
+	{
+		// TODO: Implement isMethodSupported() method.
+	}
+
+	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
+	{
+		// TODO: Implement getTypeFromMethodCall() method.
+	}
+
+	public function doFoo(object $o): void
+	{
+		if (is_a($o, \stdClass::class)) {
+
+		}
+		if (is_subclass_of($o, \stdClass::class)) {
+
+		}
+		$p = class_parents($o);
+		$i = class_implements($o);
+		$t = class_uses($o);
+	}
+
+}