RestrictedInternalClassNameUsageExtension - report static method call on internal subclass

Author: ondrejmirtes

src/Rules/ClassNameUsageLocation.php

@@ -2,7 +2,7 @@
 
 namespace PHPStan\Rules;
 
-use function array_key_exists;
+use PHPStan\Reflection\ExtendedMethodReflection;
 use function sprintf;
 use function ucfirst;
 
@@ -39,26 +39,26 @@ final class ClassNameUsageLocation
 	public const PHPDOC_TAG_TEMPLATE_BOUND = 'templateBound';
 	public const PHPDOC_TAG_TEMPLATE_DEFAULT = 'templateDefault';
 
-	/** @var array<string, self> */
-	public static array $registry = [];
-
 	/**
 	 * @param self::* $value
+	 * @param mixed[] $data
 	 */
-	private function __construct(public readonly string $value)
+	private function __construct(public readonly string $value, public readonly array $data)
 	{
 	}
 
 	/**
 	 * @param self::* $value
+	 * @param mixed[] $data
 	 */
-	public static function from(string $value): self
+	public static function from(string $value, array $data = []): self
 	{
-		if (array_key_exists($value, self::$registry)) {
-			return self::$registry[$value];
-		}
+		return new self($value, $data);
+	}
 
-		return self::$registry[$value] = new self($value);
+	public function getMethod(): ?ExtendedMethodReflection
+	{
+		return $this->data['method'] ?? null;
 	}
 
 	public function createMessage(string $part): string
@@ -111,6 +111,11 @@ public function createMessage(string $part): string
 			case self::PHPDOC_TAG_REQUIRE_IMPLEMENTS:
 				return sprintf('PHPDoc tag @phpstan-require-implements references %s.', $part);
 			case self::STATIC_METHOD_CALL:
+				$method = $this->getMethod();
+				if ($method !== null) {
+					return sprintf('Call to static method %s() on %s.', $method->getName(), $part);
+				}
+
 				return sprintf('Call to static method on %s.', $part);
 			case self::PHPDOC_TAG_TEMPLATE_BOUND:
 				return sprintf('PHPDoc tag @template bound references %s.', $part);

src/Rules/InternalTag/RestrictedInternalClassNameUsageExtension.php

@@ -34,7 +34,12 @@ public function isRestrictedClassNameUsage(
 		}
 
 		if ($location->value === ClassNameUsageLocation::STATIC_METHOD_CALL) {
-			return null;
+			$method = $location->getMethod();
+			if ($method !== null) {
+				if ($method->isInternal()->yes() || $method->getDeclaringClass()->isInternal()) {
+					return null;
+				}
+			}
 		}
 
 		return RestrictedUsage::create(

src/Rules/Methods/StaticMethodCallCheck.php

@@ -140,10 +140,16 @@ public function check(
 					];
 				}
 
+				$locationData = [];
+				$locationClassReflection = $this->reflectionProvider->getClass($className);
+				if ($locationClassReflection->hasMethod($methodName)) {
+					$locationData['method'] = $locationClassReflection->getMethod($methodName, $scope);
+				}
+
 				$errors = $this->classCheck->checkClassNames(
 					$scope,
 					[new ClassNameNodePair($className, $class)],
-					ClassNameUsageLocation::from(ClassNameUsageLocation::STATIC_METHOD_CALL),
+					ClassNameUsageLocation::from(ClassNameUsageLocation::STATIC_METHOD_CALL, $locationData),
 				);
 
 				$classType = $scope->resolveTypeByName($class);

tests/PHPStan/Rules/InternalTag/RestrictedInternalStaticMethodUsageExtensionTest.php

@@ -56,4 +56,14 @@ public function testRule(): void
 		]);
 	}
 
+	public function testStaticMethodCallOnInternalSubclass(): void
+	{
+		$this->analyse([__DIR__ . '/data/static-method-call-on-internal-subclass.php'], [
+			[
+				'Call to static method doBar() of internal class StaticMethodCallOnInternalSubclassOne\Bar from outside its root namespace StaticMethodCallOnInternalSubclassOne.',
+				34,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/InternalTag/data/static-method-call-on-internal-subclass.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace StaticMethodCallOnInternalSubclassOne {
+
+	class Foo
+	{
+		public static function doFoo(): void
+		{
+
+		}
+	}
+
+	/**
+	 * @internal
+	 */
+	class Bar extends Foo
+	{
+
+		public static function doBar(): void
+		{
+
+		}
+
+	}
+
+}
+
+namespace StaticMethodCallOnInternalSubclassTwo {
+
+	use StaticMethodCallOnInternalSubclassOne\Bar;
+
+	function (): void {
+		Bar::doFoo();
+		Bar::doBar();
+	};
+}

tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php

@@ -899,4 +899,18 @@ public function testDynamicCall(): void
 		]);
 	}
 
+	public function testRestrictedInternalClassNameUsage(): void
+	{
+		$this->checkThisOnly = false;
+		$this->checkExplicitMixed = true;
+		$this->checkImplicitMixed = true;
+
+		$this->analyse([__DIR__ . '/../InternalTag/data/static-method-call-on-internal-subclass.php'], [
+			[
+				'Call to static method doFoo() on internal class StaticMethodCallOnInternalSubclassOne\Bar.',
+				33,
+			],
+		]);
+	}
+
 }