Bleeding edge - private constant accessed through static::

conf/config.level2.neon

@@ -7,6 +7,8 @@ parameters:
 	checkPhpDocMissingReturn: true
 
 conditionalTags:
+	PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule:
+		phpstan.rules.rule: %featureToggles.privateStaticCall%
 	PHPStan\Rules\PhpDoc\IncompatibleClassConstantPhpDocTypeRule:
 		phpstan.rules.rule: %featureToggles.classConstants%
 	PHPStan\Rules\Methods\CallPrivateMethodThroughStaticRule:
@@ -40,6 +42,8 @@ rules:
 	- PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule
 
 services:
+	-
+		class: PHPStan\Rules\Classes\AccessPrivateConstantThroughStaticRule
 	-
 		class: PHPStan\Rules\Classes\MixinRule
 		arguments:

src/Rules/Classes/AccessPrivateConstantThroughStaticRule.php

@@ -0,0 +1,60 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Classes;
+
+use PhpParser\Node;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<Node\Expr\ClassConstFetch>
+ */
+class AccessPrivateConstantThroughStaticRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return Node\Expr\ClassConstFetch::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if (!$node->name instanceof Node\Identifier) {
+			return [];
+		}
+		if (!$node->class instanceof Name) {
+			return [];
+		}
+
+		$constantName = $node->name->name;
+		$className = $node->class;
+		if ($className->toLowerString() !== 'static') {
+			return [];
+		}
+
+		$classType = $scope->resolveTypeByName($className);
+		if (!$classType->hasConstant($constantName)->yes()) {
+			return [];
+		}
+
+		$constant = $classType->getConstant($constantName);
+		if (!$constant->isPrivate()) {
+			return [];
+		}
+
+		if ($scope->isInClass() && $scope->getClassReflection()->isFinal()) {
+			return [];
+		}
+
+		return [
+			RuleErrorBuilder::message(sprintf(
+				'Unsafe access to private constant %s::%s through static::.',
+				$constant->getDeclaringClass()->getDisplayName(),
+				$constantName
+			))->build(),
+		];
+	}
+
+}

src/Type/Php/ArrayFillFunctionReturnTypeExtension.php

@@ -37,7 +37,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		if (
 			$startIndexType instanceof ConstantIntegerType
 			&& $numberType instanceof ConstantIntegerType
-			&& $numberType->getValue() <= static::MAX_SIZE_USE_CONSTANT_ARRAY
+			&& $numberType->getValue() <= self::MAX_SIZE_USE_CONSTANT_ARRAY
 		) {
 			$arrayBuilder = ConstantArrayTypeBuilder::createEmpty();
 			$nextIndex = $startIndexType->getValue();

tests/PHPStan/Rules/Classes/AccessPrivateConstantThroughStaticRuleTest.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Classes;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<AccessPrivateConstantThroughStaticRule>
+ */
+class AccessPrivateConstantThroughStaticRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new AccessPrivateConstantThroughStaticRule();
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/access-private-constant-static.php'], [
+			[
+				'Unsafe access to private constant AccessPrivateConstantThroughStatic\Foo::FOO through static::.',
+				12,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php

@@ -143,13 +143,17 @@ public function testClassConstantVisibility(): void
 				'Cannot access constant FOO on int|string.',
 				116,
 			],
+			[
+				'Access to undefined constant static(ClassConstantVisibility\AccessWithStatic)::BAR.',
+				129,
+			],
 			[
 				'Class ClassConstantVisibility\Foo referenced with incorrect case: ClassConstantVisibility\FOO.',
-				122,
+				135,
 			],
 			[
 				'Access to private constant PRIVATE_FOO of class ClassConstantVisibility\Foo.',
-				122,
+				135,
 			],
 		]);
 	}

tests/PHPStan/Rules/Classes/data/access-private-constant-static.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace AccessPrivateConstantThroughStatic;
+
+class Foo
+{
+
+	private const FOO = 1;
+
+	public function doFoo()
+	{
+		static::FOO;
+		static::BAR; // reported by a different rule
+	}
+
+}
+
+final class Bar
+{
+
+	private const FOO = 1;
+
+	public function doFoo()
+	{
+		static::FOO;
+		static::BAR; // reported by a different rule
+	}
+
+}

tests/PHPStan/Rules/Classes/data/class-constant-visibility.php

@@ -118,6 +118,19 @@ public function doIpsum(WithFooConstant $foo)
 
 }
 
+class AccessWithStatic
+{
+
+	private const FOO = 1;
+
+	public function doFoo()
+	{
+		static::FOO; // reported by a different rule
+		static::BAR;
+	}
+
+}
+
 function () {
 	FOO::PRIVATE_FOO;
 };