forked from phpstan/phpstan-src
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathAttributeReflectionFactory.php
More file actions
143 lines (121 loc) · 3.94 KB
/
Copy pathAttributeReflectionFactory.php
File metadata and controls
143 lines (121 loc) · 3.94 KB
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
<?php declare(strict_types = 1);
namespace PHPStan\Reflection;
use PhpParser\Node\AttributeGroup;
use PhpParser\Node\Expr;
use PHPStan\BetterReflection\Reflection\Adapter\FakeReflectionAttribute;
use PHPStan\BetterReflection\Reflection\Adapter\ReflectionAttribute;
use PHPStan\DependencyInjection\AutowiredService;
use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
use PHPStan\Type\TypeCombinator;
use function array_key_exists;
use function array_last;
use function count;
use function is_int;
#[AutowiredService]
final class AttributeReflectionFactory
{
public function __construct(
private InitializerExprTypeResolver $initializerExprTypeResolver,
private ReflectionProviderProvider $reflectionProviderProvider,
)
{
}
/**
* @param list<ReflectionAttribute|FakeReflectionAttribute> $reflections
* @return list<AttributeReflection>
*/
public function fromNativeReflection(array $reflections, InitializerExprContext $context): array
{
$attributes = [];
foreach ($reflections as $reflection) {
$attribute = $this->fromNameAndArgumentExpressions($reflection->getName(), $reflection->getArgumentsExpressions(), $context);
if ($attribute === null) {
continue;
}
$attributes[] = $attribute;
}
return $attributes;
}
/**
* @param AttributeGroup[] $attrGroups
* @return list<AttributeReflection>
*/
public function fromAttrGroups(array $attrGroups, InitializerExprContext $context): array
{
$attributes = [];
foreach ($attrGroups as $attrGroup) {
foreach ($attrGroup->attrs as $attr) {
$arguments = [];
foreach ($attr->args as $i => $arg) {
if ($arg->name === null) {
$argName = $i;
} else {
$argName = $arg->name->toString();
}
$arguments[$argName] = $arg->value;
}
$attributeReflection = $this->fromNameAndArgumentExpressions($attr->name->toString(), $arguments, $context);
if ($attributeReflection === null) {
continue;
}
$attributes[] = $attributeReflection;
}
}
return $attributes;
}
/**
* @param array<int|string, Expr> $arguments
*/
private function fromNameAndArgumentExpressions(string $name, array $arguments, InitializerExprContext $context): ?AttributeReflection
{
if (count($arguments) === 0) {
return new AttributeReflection($name, []);
}
$reflectionProvider = $this->reflectionProviderProvider->getReflectionProvider();
if (!$reflectionProvider->hasClass($name)) {
return null;
}
$classReflection = $reflectionProvider->getClass($name);
if (!$classReflection->hasConstructor()) {
return null;
}
if (!$classReflection->isAttributeClass()) {
return null;
}
$className = $classReflection->getName();
$nativeConstructor = $classReflection->getNativeReflection()->getConstructor();
if ($nativeConstructor === null) {
return null;
}
$nativeParameters = $nativeConstructor->getParameters();
$namedArgTypes = [];
foreach ($arguments as $i => $argExpr) {
if (is_int($i)) {
if (isset($nativeParameters[$i])) {
$namedArgTypes[$nativeParameters[$i]->getName()] = $this->initializerExprTypeResolver->getType($argExpr, $context);
continue;
}
if (count($nativeParameters) > 0) {
$lastParameter = array_last($nativeParameters);
if ($lastParameter->isVariadic()) {
$parameterName = $lastParameter->getName();
if (array_key_exists($parameterName, $namedArgTypes)) {
$namedArgTypes[$parameterName] = TypeCombinator::union($namedArgTypes[$parameterName], $this->initializerExprTypeResolver->getType($argExpr, $context));
continue;
}
$namedArgTypes[$parameterName] = $this->initializerExprTypeResolver->getType($argExpr, $context);
}
}
continue;
}
foreach ($nativeParameters as $parameter) {
if ($parameter->getName() !== $i) {
continue;
}
$namedArgTypes[$i] = $this->initializerExprTypeResolver->getType($argExpr, $context);
break;
}
}
return new AttributeReflection($className, $namedArgTypes);
}
}