MemoizationPropertyRule supports static properties

Author: zonuexe

build/PHPStan/Build/MemoizationPropertyRule.php

@@ -3,23 +3,28 @@
 namespace PHPStan\Build;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\AssignOp\Coalesce;
 use PhpParser\Node\Expr\BinaryOp\Identical;
 use PhpParser\Node\Expr\ConstFetch;
 use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\If_;
 use PhpParser\Node\Stmt\Return_;
+use PhpParser\Node\VarLikeIdentifier;
 use PHPStan\Analyser\Scope;
 use PHPStan\File\FileHelper;
 use PHPStan\Node\InClassMethodNode;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use function count;
 use function dirname;
+use function is_string;
 use function sprintf;
 use function str_starts_with;
 use function strcasecmp;
@@ -52,11 +57,7 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		[$ifNode, $returnNode] = $stmts;
-		if (!$returnNode instanceof Return_
-			|| !$returnNode->expr instanceof PropertyFetch
-			|| !$returnNode->expr->var instanceof Variable
-			|| !$returnNode->expr->name instanceof Identifier
-		) {
+		if (!$returnNode instanceof Return_ || !$this->isSupportedFetchNode($returnNode->expr)) {
 			return [];
 		}
 
@@ -66,23 +67,19 @@ public function processNode(Node $node, Scope $scope): array
 			|| count($ifNode->elseifs) !== 0
 			|| $ifNode->else !== null
 			|| !$ifNode->cond instanceof Identical
-			|| !$ifNode->cond->left instanceof PropertyFetch
-			|| !$ifNode->cond->left->var instanceof Variable
-			|| !$ifNode->cond->left->name instanceof Identifier
+			|| !$this->isSupportedFetchNode($ifNode->cond->left)
 			|| !$ifNode->cond->right instanceof ConstFetch
 			|| strcasecmp($ifNode->cond->right->name->name, 'null') !== 0
 		) {
 			return [];
 		}
 
 		$ifThenNode = $ifNode->stmts[0]->expr;
-		if (!$ifThenNode instanceof Assign || !$ifThenNode->var instanceof PropertyFetch) {
+		if (!$ifThenNode instanceof Assign || !$this->isSupportedFetchNode($ifThenNode->var)) {
 			return [];
 		}
 
-		if ($returnNode->expr->var->name !== $ifNode->cond->left->var->name
-			|| $returnNode->expr->name->name !== $ifNode->cond->left->name->name
-		) {
+		if ($this->areNodesNotEqual($returnNode->expr, [$ifNode->cond->left, $ifThenNode->var])) {
 			return [];
 		}
 
@@ -91,9 +88,15 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$classReflection = $node->getClassReflection();
+		$methodReflection = $node->getMethodReflection();
 		$methodName = $methodNode->name->name;
 		$errorBuilder = RuleErrorBuilder::message(
-			sprintf('Method %s::%s() for memoization can be simplified.', $classReflection->getDisplayName(), $methodName),
+			sprintf(
+				'%s %s::%s() for memoization can be simplified.',
+				$methodReflection->isStatic() ? 'Static method' : 'Method',
+				$classReflection->getDisplayName(),
+				$methodName,
+			),
 		)->fixNode($node->getOriginalNode(), static function (Node\Stmt\ClassMethod $method) use ($ifThenNode) {
 			$method->stmts = [
 				new Return_(
@@ -109,4 +112,71 @@ public function processNode(Node $node, Scope $scope): array
 		];
 	}
 
+	/**
+	 * @phpstan-assert-if-true PropertyFetch|StaticPropertyFetch $node
+	 */
+	private function isSupportedFetchNode(?Expr $node): bool
+	{
+		return $node instanceof PropertyFetch || $node instanceof StaticPropertyFetch;
+	}
+
+	/**
+	 * @param list<PropertyFetch|StaticPropertyFetch> $otherNodes
+	 */
+	private function areNodesNotEqual(PropertyFetch|StaticPropertyFetch $node, array $otherNodes): bool
+	{
+		if ($node instanceof PropertyFetch) {
+			if (!$node->var instanceof Variable
+				|| !is_string($node->var->name)
+				|| !$node->name instanceof Identifier
+			) {
+				return true;
+			}
+
+			foreach ($otherNodes as $otherNode) {
+				if (!$otherNode instanceof PropertyFetch) {
+					return true;
+				}
+				if (!$otherNode->var instanceof Variable
+					|| !is_string($otherNode->var->name)
+					|| !$otherNode->name instanceof Identifier
+				) {
+					return true;
+				}
+
+				if ($node->var->name !== $otherNode->var->name
+					|| $node->name->name !== $otherNode->name->name
+				) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		if (!$node->class instanceof Name || !$node->name instanceof VarLikeIdentifier) {
+			return true;
+		}
+
+		foreach ($otherNodes as $otherNode) {
+			if (!$otherNode instanceof StaticPropertyFetch) {
+				return true;
+			}
+
+			if (!$otherNode->class instanceof Name
+				|| !$otherNode->name instanceof VarLikeIdentifier
+			) {
+				return true;
+			}
+
+			if ($node->class->toLowerString() !== $otherNode->class->toLowerString()
+				|| $node->name->toString() !== $otherNode->name->toString()
+			) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 }

tests/PHPStan/Build/MemoizationPropertyRuleTest.php

@@ -29,6 +29,10 @@ public function testRule(): void
 				'Method MemoizationProperty\A::getBar() for memoization can be simplified.',
 				20,
 			],
+			[
+				'Static method MemoizationProperty\A::singleton() for memoization can be simplified.',
+				96,
+			],
 		]);
 	}
 

tests/PHPStan/Build/data/memoization-property.php

@@ -91,4 +91,25 @@ public function printFoo(): void
 		echo $this->foo;
 	}
 
+	private static ?self $singleton = null;
+
+	public static function singleton(): self
+	{
+		if (self::$singleton === null) {
+			self::$singleton = new self();
+		}
+
+		return self::$singleton;
+	}
+
+	/** Not applicable because property names are not matched. */
+	public static function singletonBadProperty(): self
+	{
+		if (self::$singleton === null) {
+			self::$singletom = new self();
+		}
+
+		return self::$singleton;
+	}
+
 }

tests/PHPStan/Build/data/memoization-property.php.fixed

@@ -83,4 +83,21 @@ final class A
 		echo $this->foo;
 	}
 
+	private static ?self $singleton = null;
+
+	public static function singleton(): self
+	{
+		return self::$singleton ??= new self();
+	}
+
+	/** Not applicable because property names are not matched. */
+	public static function singletonBadProperty(): self
+	{
+		if (self::$singleton === null) {
+			self::$singletom = new self();
+		}
+
+		return self::$singleton;
+	}
+
 }