ClassConstantRuleTest.php

<?php declare(strict_types = 1);

namespace PHPStan\Rules\Classes;

use PHPStan\Classes\ForbiddenClassNameExtension;
use PHPStan\Rules\ClassCaseSensitivityCheck;
use PHPStan\Rules\ClassForbiddenNameCheck;
use PHPStan\Rules\ClassNameCheck;
use PHPStan\Rules\NonStringableDynamicAccessCheck;
use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension;
use PHPStan\Rules\Rule;
use PHPStan\Rules\RuleLevelHelper;
use PHPStan\Testing\RuleTestCase;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\RequiresPhp;
use const PHP_VERSION_ID;

/**
 * @extends RuleTestCase<ClassConstantRule>
 */
class ClassConstantRuleTest extends RuleTestCase
{

	private bool $checkImportedClassNameCase = false;

	protected function getRule(): Rule
	{
		$reflectionProvider = self::createReflectionProvider();
		$container = self::getContainer();
		$ruleLevelHelper = new RuleLevelHelper(
			$reflectionProvider,
			checkNullables: true,
			checkThisOnly: false,
			checkUnionTypes: true,
			checkExplicitMixed: true,
			checkImplicitMixed: true,
			checkBenevolentUnionTypes: false,
			discoveringSymbolsTip: true,
		);
		return new ClassConstantRule(
			$reflectionProvider,
			$ruleLevelHelper,
			new ClassNameCheck(
				new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true, checkImportedClassNameCase: $this->checkImportedClassNameCase),
				new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)),
				$reflectionProvider,
				$container->getExtensionsCollection(RestrictedClassNameUsageExtension::class),
			),
			new NonStringableDynamicAccessCheck($ruleLevelHelper, true),
		);
	}

	public function testClassConstant(): void
	{
		$this->analyse(
			[
				__DIR__ . '/data/class-constant.php',
				__DIR__ . '/data/class-constant-defined.php',
			],
			[
				[
					'Class ClassConstantNamespace\Bar not found.',
					6,
					'Learn more at https://phpstan.org/user-guide/discovering-symbols',
				],
				[
					'Using self outside of class scope.',
					7,
				],
				[
					'Access to undefined constant ClassConstantNamespace\Foo::DOLOR.',
					10,
				],
				[
					'Cannot access constant LOREM on mixed.',
					11,
				],
				[
					'Access to undefined constant ClassConstantNamespace\Foo::DOLOR.',
					16,
				],
				[
					'Using static outside of class scope.',
					18,
				],
				[
					'Using parent outside of class scope.',
					19,
				],
				[
					'Access to constant FOO on an unknown class ClassConstantNamespace\UnknownClass.',
					21,
					'Learn more at https://phpstan.org/user-guide/discovering-symbols',
				],
				[
					'Class ClassConstantNamespace\Foo referenced with incorrect case: ClassConstantNamespace\FOO.',
					26,
				],
				[
					'Class ClassConstantNamespace\Foo referenced with incorrect case: ClassConstantNamespace\FOO.',
					27,
				],
				[
					'Access to undefined constant ClassConstantNamespace\Foo::DOLOR.',
					27,
				],
				[
					'Class ClassConstantNamespace\Foo referenced with incorrect case: ClassConstantNamespace\FOO.',
					28,
				],
				[
					'Access to undefined constant ClassConstantNamespace\Foo|string::DOLOR.',
					33,
				],
			],
		);
	}

	public function testClassConstantVisibility(): void
	{
		$this->analyse([__DIR__ . '/data/class-constant-visibility.php'], [
			[
				'Access to private constant PRIVATE_BAR of class ClassConstantVisibility\Bar.',
				25,
			],
			[
				'Access to parent::BAZ but ClassConstantVisibility\Foo does not extend any class.',
				27,
			],
			[
				'Access to undefined constant ClassConstantVisibility\Bar::PRIVATE_FOO.',
				45,
			],
			[
				'Access to private constant PRIVATE_FOO of class ClassConstantVisibility\Foo.',
				46,
			],
			[
				'Access to private constant PRIVATE_FOO of class ClassConstantVisibility\Foo.',
				47,
			],
			[
				'Access to undefined constant ClassConstantVisibility\Bar::PRIVATE_FOO.',
				60,
			],
			[
				'Access to protected constant PROTECTED_FOO of class ClassConstantVisibility\Foo.',
				71,
			],
			[
				'Access to undefined constant ClassConstantVisibility\WithFooAndBarConstant&ClassConstantVisibility\WithFooConstant::BAZ.',
				106,
			],
			[
				'Access to undefined constant ClassConstantVisibility\WithFooAndBarConstant|ClassConstantVisibility\WithFooConstant::BAR.',
				110,
			],
			[
				'Access to constant FOO on an unknown class ClassConstantVisibility\UnknownClassFirst.',
				112,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
			[
				'Access to constant FOO on an unknown class ClassConstantVisibility\UnknownClassSecond.',
				112,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
			[
				'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.',
				135,
			],
			[
				'Access to private constant PRIVATE_FOO of class ClassConstantVisibility\Foo.',
				135,
			],
		]);
	}

	#[RequiresPhp('>= 8.0.0')]
	public function testClosureBindNamedArguments(): void
	{
		$this->analyse([__DIR__ . '/data/closure-bind-named-arguments.php'], [
			[
				'Access to protected constant C of class ClosureBindNamedArgumentsConstant\\Target.',
				53,
			],
		]);
	}

	public function testClassExists(): void
	{
		$this->analyse([__DIR__ . '/data/class-exists.php'], [
			[
				'Class UnknownClass\Bar not found.',
				24,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
			[
				'Class UnknownClass\Foo not found.',
				26,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
			[
				'Class UnknownClass\Foo not found.',
				29,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
		]);
	}

	#[RequiresPhp('>= 8.0.0')]
	public function testEnumExists(): void
	{
		$this->analyse([__DIR__ . '/data/enum-exists.php'], [
			[
				'Class UnknownEnum\Foo not found.',
				7,
				'Learn more at https://phpstan.org/user-guide/discovering-symbols',
			],
		]);
	}

	public function testClassConstantOnExpression(): void
	{
		if (PHP_VERSION_ID < 80000) {
			$errors = [
				[
					'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
					15,
				],
				[
					'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
					16,
				],
				[
					'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
					17,
				],
				[
					'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
					18,
				],
				[
					'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
					19,
				],
			];
		} else {
			$errors = [
				[
					'Accessing ::class constant on a dynamic string is not supported in PHP.',
					16,
				],
				[
					'Cannot access constant class on stdClass|null.',
					17,
				],
				[
					'Cannot access constant class on string|null.',
					18,
				],
			];
		}

		$this->analyse([__DIR__ . '/data/class-constant-on-expr.php'], $errors);
	}

	public function testAttributes(): void
	{
		$this->analyse([__DIR__ . '/data/class-constant-attribute.php'], [
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				5,
			],
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				9,
			],
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				12,
			],
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				15,
			],
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				17,
			],
			[
				'Access to private constant FOO of class ClassConstantAttribute\Foo.',
				26,
			],
			[
				'Access to undefined constant ClassConstantAttribute\Foo::BAR.',
				26,
			],
		]);
	}

	#[RequiresPhp('>= 8.0.0')]
	public function testRuleWithNullsafeVariant(): void
	{
		$this->analyse([__DIR__ . '/data/class-constant-nullsafe.php'], []);
	}

	public function testBug7675(): void
	{
		$this->analyse([__DIR__ . '/data/bug-7675.php'], []);
	}

	public function testBug8034(): void
	{
		$this->analyse([__DIR__ . '/data/bug-8034.php'], [
			[
				'Access to undefined constant static(Bug8034\HelloWorld)::FIELDS.',
				19,
			],
		]);
	}

	public function testClassConstFetchDefined(): void
	{
		$this->analyse([__DIR__ . '/data/class-const-fetch-defined.php'], [
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				12,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				14,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				16,
			],
			[
				'Access to undefined constant Foo::TEST.',
				17,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				18,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				22,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				24,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				26,
			],
			[
				'Access to undefined constant Foo::TEST.',
				27,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				28,
			],
			[
				'Access to undefined constant Foo::TEST.',
				33,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				36,
			],
			[
				'Access to undefined constant Foo::TEST.',
				37,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				38,
			],
			[
				'Access to undefined constant Foo::TEST.',
				43,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				46,
			],
			[
				'Access to undefined constant Foo::TEST.',
				47,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				48,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				52,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				54,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				56,
			],
			[
				'Access to undefined constant Foo::TEST.',
				57,
			],
			[
				'Access to undefined constant ClassConstFetchDefined\Foo::TEST.',
				58,
			],
		]);
	}

	public function testPhpstanInternalClass(): void
	{
		$tip = 'This is most likely unintentional. Did you mean to type \AClass?';

		$this->analyse([__DIR__ . '/data/phpstan-internal-class.php'], [
			[
				'Referencing prefixed PHPStan class: _PHPStan_156ee64ba\AClass.',
				28,
				$tip,
			],
		]);
	}

	#[RequiresPhp('>= 8.2.0')]
	public function testClassConstantAccessedOnTrait(): void
	{
		$this->analyse([__DIR__ . '/data/class-constant-accessed-on-trait.php'], [
			[
				'Cannot access constant TEST on trait ClassConstantAccessedOnTrait\Foo.',
				16,
			],
		]);
	}

	#[RequiresPhp('>= 8.3.0')]
	public function testDynamicAccess(): void
	{
		$this->analyse([__DIR__ . '/data/dynamic-constant-access.php'], [
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::FOO.',
				17,
			],
			[
				'Class constant name for ClassConstantDynamicAccess\Foo must be a string, but object was given.',
				19,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::FOO.',
				20,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::BUZ.',
				20,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::FOO.',
				37,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::BUZ.',
				39,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::QUX.',
				41,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::QUX.',
				44,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::BUZ.',
				44,
			],
			[
				'Access to undefined constant ClassConstantDynamicAccess\Foo::FOO.',
				44,
			],
		]);
	}

	#[RequiresPhp('>= 8.3.0')]
	public function testStringableDynamicAccess(): void
	{
		$this->analyse([__DIR__ . '/data/dynamic-constant-stringable-access.php'], [
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but mixed was given.',
				14,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but string|null was given.',
				15,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but Stringable|null was given.',
				16,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but int was given.',
				17,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but int|null was given.',
				18,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but DateTime|string was given.',
				19,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but 1111 was given.',
				20,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but Stringable was given.',
				22,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Foo must be a string, but mixed was given.',
				32,
			],
			[
				'Class constant name for ClassConstantDynamicStringableAccess\Bar must be a string, but mixed was given.',
				33,
			],
			[
				'Class constant name for DateTime|DateTimeImmutable must be a string, but mixed was given.',
				38,
			],
			[
				'Class constant name for object must be a string, but mixed was given.',
				39,
			],
		]);
	}

	public static function dataBug12827(): array
	{
		return [
			[true],
			[false],
		];
	}

	#[DataProvider('dataBug12827')]
	public function testBug12827(bool $checkImportedClassNameCase): void
	{
		$this->checkImportedClassNameCase = $checkImportedClassNameCase;

		$expectedErrors = [];
		if ($checkImportedClassNameCase) {
			$expectedErrors[] = [
				'Class Bug12827Classes\Post referenced with incorrect case: Bug12827Classes\POST.',
				29,
			];
			$expectedErrors[] = [
				'Class Bug12827Classes\Post referenced with incorrect case: Bug12827Classes\POST.',
				39,
			];
		}

		$this->analyse([__DIR__ . '/data/bug-12827.php'], $expectedErrors);
	}

	#[DataProvider('dataBug12827')]
	#[RequiresPhp('>= 8.1.0')]
	public function testBug12827Enum(bool $checkImportedClassNameCase): void
	{
		$this->checkImportedClassNameCase = $checkImportedClassNameCase;

		$expectedErrors = [];
		if ($checkImportedClassNameCase) {
			$expectedErrors[] = [
				'Enum Bug12827Enum\Suit referenced with incorrect case: Bug12827Enum\SUIT.',
				17,
			];
		}

		$this->analyse([__DIR__ . '/data/bug-12827-enum.php'], $expectedErrors);
	}

	public function testConditionallyExecutedClassConstantOnExpression(): void
	{
		$errors = [
			[
				'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
				12,
			],
		];
		if (PHP_VERSION_ID < 80000) {
			$errors[] = [
				'Accessing ::class constant on an expression is supported only on PHP 8.0 and later.',
				15,
			];
		}

		$this->analyse([__DIR__ . '/data/class-constant-on-expr-php-versions.php'], $errors);
	}

	#[RequiresPhp('>= 8.0.0')]
	public function testClosureAttributeArguments(): void
	{
		$tip = 'Learn more at https://phpstan.org/user-guide/discovering-symbols';
		$this->analyse([__DIR__ . '/data/closure-attribute-class-constant.php'], [
			[
				'Access to constant FOO on an unknown class ClosureAttributeClassConstant\\Missing.',
				26,
				$tip,
			],
			[
				'Access to constant FOO on an unknown class ClosureAttributeClassConstant\\Missing.',
				27,
				$tip,
			],
			[
				'Access to constant FOO on an unknown class ClosureAttributeClassConstant\\Missing.',
				28,
				$tip,
			],
			[
				'Access to undefined constant ClosureAttributeClassConstant\\Foo::BAR.',
				29,
			],
			[
				'Access to constant FOO on an unknown class ClosureAttributeClassConstant\\Missing.',
				29,
				$tip,
			],
		]);
	}

}