phpstan-src/src/Type/Php/PropertyExistsTypeSpecifyingExtension.php at 096ab286b9dba582fa56708e6f4b37bd52b3e4eb · phpstan/phpstan-src · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
<?php declare(strict_types = 1);

namespace PHPStan\Type\Php;

use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name\FullyQualified;
use PHPStan\Analyser\Scope;
use PHPStan\Analyser\SpecifiedTypes;
use PHPStan\Analyser\TypeSpecifier;
use PHPStan\Analyser\TypeSpecifierAwareExtension;
use PHPStan\Analyser\TypeSpecifierContext;
use PHPStan\DependencyInjection\AutowiredService;
use PHPStan\Reflection\FunctionReflection;
use PHPStan\Rules\Properties\PropertyReflectionFinder;
use PHPStan\Type\Accessory\HasPropertyType;
use PHPStan\Type\ClassStringType;
use PHPStan\Type\Constant\ConstantBooleanType;
use PHPStan\Type\Constant\ConstantStringType;
use PHPStan\Type\FunctionTypeSpecifyingExtension;
use PHPStan\Type\IntersectionType;
use PHPStan\Type\ObjectWithoutClassType;
use PHPStan\Type\UnionType;
use function count;

#[AutowiredService]
final class PropertyExistsTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
{

	private TypeSpecifier $typeSpecifier;

	public function __construct(private PropertyReflectionFinder $propertyReflectionFinder)
	{
	}

	public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
	{
		$this->typeSpecifier = $typeSpecifier;
	}

	public function isFunctionSupported(
		FunctionReflection $functionReflection,
		FuncCall $node,
		TypeSpecifierContext $context,
	): bool
	{
		return $functionReflection->getName() === 'property_exists'
			&& $context->true()
			&& count($node->getArgs()) >= 2;
	}

	public function specifyTypes(
		FunctionReflection $functionReflection,
		FuncCall $node,
		Scope $scope,
		TypeSpecifierContext $context,
	): SpecifiedTypes
	{
		$args = $node->getArgs();
		$propertyNameType = $scope->getType($args[1]->value);
		if (!$propertyNameType instanceof ConstantStringType) {
			return $this->typeSpecifier->create(
				new FuncCall(new FullyQualified('property_exists'), $node->getRawArgs()),
				new ConstantBooleanType(true),
				$context,
				$scope,
			);
		}

		if ($propertyNameType->getValue() === '') {
			return new SpecifiedTypes([], []);
		}

		$objectType = $scope->getType($args[0]->value);
		if ($objectType->isString()->yes()) {
			return $this->typeSpecifier->create(
				new FuncCall(new FullyQualified('property_exists'), $node->getRawArgs()),
				new ConstantBooleanType(true),
				$context,
				$scope,
			);
		}

		if (!$objectType->isObject()->yes()) {
			return $this->typeSpecifier->create(
				$args[0]->value,
				new UnionType([
					new IntersectionType([
						new ObjectWithoutClassType(),
						new HasPropertyType($propertyNameType->getValue()),
					]),
					new ClassStringType(),
				]),
				$context,
				$scope,
			);
		}

		$propertyNode = new PropertyFetch(
			$args[0]->value,
			new Identifier($propertyNameType->getValue()),
		);

		$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($propertyNode, $scope);
		if ($propertyReflection !== null) {
			if (!$propertyReflection->isNative()) {
				return new SpecifiedTypes([], []);
			}
		}

		return $this->typeSpecifier->create(
			$args[0]->value,
			new IntersectionType([
				new ObjectWithoutClassType(),
				new HasPropertyType($propertyNameType->getValue()),
			]),
			$context,
			$scope,
		);
	}

}