VariablePropertyFetchRule - allow universal object crate classes

Author: ondrejmirtes

rules.neon

@@ -41,11 +41,16 @@ rules:
 	- PHPStan\Rules\VariableVariables\VariableMethodCallRule
 	- PHPStan\Rules\VariableVariables\VariableStaticMethodCallRule
 	- PHPStan\Rules\VariableVariables\VariableStaticPropertyFetchRule
-	- PHPStan\Rules\VariableVariables\VariablePropertyFetchRule
 	- PHPStan\Rules\VariableVariables\VariableVariablesRule
 
 services:
 	-
 		class: PHPStan\Rules\BooleansInConditions\BooleanRuleHelper
 	-
 		class: PHPStan\Rules\Operators\OperatorRuleHelper
+	-
+		class: PHPStan\Rules\VariableVariables\VariablePropertyFetchRule
+		arguments:
+			universalObjectCratesClasses: %universalObjectCratesClasses%
+		tags:
+			- phpstan.rules.rule

src/Rules/VariableVariables/VariablePropertyFetchRule.php

@@ -4,12 +4,31 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Broker\Broker;
+use PHPStan\Reflection\ClassReflection;
 use PHPStan\Rules\Rule;
+use PHPStan\Type\TypeUtils;
 use PHPStan\Type\VerbosityLevel;
 
 class VariablePropertyFetchRule implements Rule
 {
 
+	/** @var Broker */
+	private $broker;
+
+	/** @var string[] */
+	private $universalObjectCratesClasses;
+
+	/**
+	 * @param Broker $broker
+	 * @param string[] $universalObjectCratesClasses
+	 */
+	public function __construct(Broker $broker, array $universalObjectCratesClasses)
+	{
+		$this->broker = $broker;
+		$this->universalObjectCratesClasses = $universalObjectCratesClasses;
+	}
+
 	public function getNodeType(): string
 	{
 		return Node\Expr\PropertyFetch::class;
@@ -26,12 +45,43 @@ public function processNode(Node $node, Scope $scope): array
 			return [];
 		}
 
+		$fetchedOnType = $scope->getType($node->var);
+		foreach (TypeUtils::getDirectClassNames($fetchedOnType) as $referencedClass) {
+			if (!$this->broker->hasClass($referencedClass)) {
+				continue;
+			}
+
+			if ($this->isUniversalObjectCrate($this->broker->getClass($referencedClass))) {
+				return [];
+			}
+		}
+
 		return [
 			sprintf(
 				'Variable property access on %s.',
-				$scope->getType($node->var)->describe(VerbosityLevel::typeOnly())
+				$fetchedOnType->describe(VerbosityLevel::typeOnly())
 			),
 		];
 	}
 
+	private function isUniversalObjectCrate(
+		ClassReflection $classReflection
+	): bool
+	{
+		foreach ($this->universalObjectCratesClasses as $className) {
+			if (!$this->broker->hasClass($className)) {
+				continue;
+			}
+
+			if (
+				$classReflection->getName() === $className
+				|| $classReflection->isSubclassOf($className)
+			) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 }

tests/Rules/VariableVariables/VariablePropertyFetchRuleTest.php

@@ -10,19 +10,18 @@ class VariablePropertyFetchRuleTest extends RuleTestCase
 
 	protected function getRule(): Rule
 	{
-		return new VariablePropertyFetchRule();
+		return new VariablePropertyFetchRule($this->createBroker(), [
+			'stdClass',
+			'SimpleXMLElement',
+		]);
 	}
 
 	public function testRule(): void
 	{
 		$this->analyse([__DIR__ . '/data/properties.php'], [
 			[
-				'Variable property access on stdClass.',
-				6,
-			],
-			[
-				'Variable property access on stdClass.',
-				9,
+				'Variable property access on VariablePropertyFetch\Foo.',
+				24,
 			],
 		]);
 	}

tests/Rules/VariableVariables/data/properties.php

@@ -1,10 +1,28 @@
 <?php
 
-function (stdClass $std) {
-	$std->foo = 'test';
-	$foo = 'bar';
-	$std->$foo = 'foo';
+namespace VariablePropertyFetch;
 
-	echo $std->foo;
-	echo $std->$foo;
+use stdClass;
+
+class Foo
+{
+
+}
+
+class Bar extends stdClass
+{
+
+}
+
+function (stdClass $std, Foo $foo, Bar $bar) {
+	$str = 'str';
+
+	$std->foo;
+	$std->$str;
+
+	$foo->foo;
+	$foo->$str;
+
+	$bar->foo;
+	$bar->$str;
 };