1: <?php declare(strict_types = 1);
2:
3: namespace PHPStan\Rules\RestrictedUsage;
4:
5: use PhpParser\Node;
6: use PhpParser\Node\Identifier;
7: use PhpParser\Node\Name;
8: use PHPStan\Analyser\Scope;
9: use PHPStan\DependencyInjection\AutowiredExtensions;
10: use PHPStan\DependencyInjection\AutowiredService;
11: use PHPStan\DependencyInjection\ExtensionsCollection;
12: use PHPStan\Reflection\ReflectionProvider;
13: use PHPStan\Rules\Rule;
14: use PHPStan\Rules\RuleErrorBuilder;
15: use PHPStan\Rules\RuleLevelHelper;
16: use PHPStan\Type\ErrorType;
17: use PHPStan\Type\Type;
18: use PHPStan\Type\TypeCombinator;
19: use function strtolower;
20:
21: /**
22: * @implements Rule<Node\Expr\ClassConstFetch>
23: */
24: #[AutowiredService]
25: final class RestrictedClassConstantUsageRule implements Rule
26: {
27:
28: /**
29: * @param ExtensionsCollection<RestrictedClassConstantUsageExtension> $extensions
30: */
31: public function __construct(
32: #[AutowiredExtensions(of: RestrictedClassConstantUsageExtension::class)]
33: private ExtensionsCollection $extensions,
34: private ReflectionProvider $reflectionProvider,
35: private RuleLevelHelper $ruleLevelHelper,
36: )
37: {
38: }
39:
40: public function getNodeType(): string
41: {
42: return Node\Expr\ClassConstFetch::class;
43: }
44:
45: /**
46: * @api
47: */
48: public function processNode(Node $node, Scope $scope): array
49: {
50: if (!$node->name instanceof Identifier) {
51: return [];
52: }
53:
54: $extensions = $this->extensions->getAll();
55: if ($extensions === []) {
56: return [];
57: }
58:
59: $constantName = $node->name->name;
60: $referencedClasses = [];
61:
62: if ($node->class instanceof Name) {
63: $referencedClasses[] = $scope->resolveName($node->class);
64: } else {
65: $classTypeResult = $this->ruleLevelHelper->findTypeToCheck(
66: $scope,
67: $node->class,
68: '', // We don't care about the error message
69: static fn (Type $type): bool => $type->canAccessConstants()->yes() && $type->hasConstant($constantName)->yes(),
70: );
71:
72: if ($classTypeResult->getType() instanceof ErrorType) {
73: return [];
74: }
75:
76: $referencedClasses = TypeCombinator::removeNull($classTypeResult->getType())->getObjectTypeOrClassStringObjectType()->getObjectClassNames();
77: }
78:
79: $errors = [];
80: foreach ($referencedClasses as $referencedClass) {
81: if (!$this->reflectionProvider->hasClass($referencedClass)) {
82: continue;
83: }
84:
85: $classReflection = $this->reflectionProvider->getClass($referencedClass);
86: if (strtolower($constantName) === 'class') {
87: $constantReflection = new ClassNameConstantReflection($classReflection);
88: } elseif ($classReflection->hasConstant($constantName)) {
89: $constantReflection = $classReflection->getConstant($constantName);
90: } else {
91: continue;
92: }
93:
94: foreach ($extensions as $extension) {
95: $restrictedUsage = $extension->isRestrictedClassConstantUsage($constantReflection, $scope);
96: if ($restrictedUsage === null) {
97: continue;
98: }
99:
100: if ($classReflection->getName() !== $constantReflection->getDeclaringClass()->getName()) {
101: $rewrittenConstantReflection = new RewrittenDeclaringClassClassConstantReflection($classReflection, $constantReflection);
102: $rewrittenRestrictedUsage = $extension->isRestrictedClassConstantUsage($rewrittenConstantReflection, $scope);
103: if ($rewrittenRestrictedUsage === null) {
104: continue;
105: }
106: }
107:
108: $errorBuilder = RuleErrorBuilder::message($restrictedUsage->errorMessage)
109: ->identifier($restrictedUsage->identifier);
110: if ($restrictedUsage->tip !== null) {
111: $errorBuilder->tip($restrictedUsage->tip);
112: }
113:
114: $errors[] = $errorBuilder->build();
115: }
116: }
117:
118: return $errors;
119: }
120:
121: }
122: