Repository navigation
Expand file tree
/
Copy pathClassResultCacheValueExtension.php
More file actions
137 lines (118 loc) · 4.41 KB
/
Copy pathClassResultCacheValueExtension.php
File metadata and controls
137 lines (118 loc) · 4.41 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
<?php declare(strict_types = 1);
namespace PHPStan\Analyser\ResultCache;
use PHPStan\Analyser\ValueDependencyCollector;
use PHPStan\BetterReflection\Reflection\ReflectionClass;
use PHPStan\Dependency\ExportedNodeFetcher;
use PHPStan\DependencyInjection\AutowiredService;
use PHPStan\File\FileContentHasher;
use PHPStan\Reflection\ReflectionProvider;
use function array_key_exists;
use function array_pop;
use function hash;
use function implode;
use function json_encode;
use function ksort;
use function ltrim;
use function sprintf;
use function strtolower;
/**
* The value behind DependencyTracker::trackClassDependency(): what the class and its parents,
* interfaces and traits declare - their exported nodes, the same that decide whether the files
* referencing a class in code are analysed again - or that the class does not exist. A changed
* signature or PHPDoc counts, an edited method body does not; so does the class being created,
* deleted or moved to another file.
*
* The key is the class name as written, without a leading backslash - not lowercased, because the
* autoloader-based lookup of a class that is not loaded yet follows the case of the name (PSR-4).
*/
#[AutowiredService]
final class ClassResultCacheValueExtension implements ResultCacheValueExtension
{
/** @var array<string, array{string, array<string, string>}> file => [content hash, lowercase name => exported node JSON] */
private array $exportedNodesByFile = [];
public function __construct(
private ReflectionProvider $reflectionProvider,
private ExportedNodeFetcher $exportedNodeFetcher,
private FileContentHasher $fileContentHasher,
)
{
}
public static function createKey(string $className): string
{
return ltrim($className, '\\');
}
public function getValue(string $key): string
{
if (!$this->reflectionProvider->hasClass($key)) {
return ValueDependencyCollector::MISSING;
}
$declarations = [];
$reflection = $this->reflectionProvider->getClass($key)->getNativeReflection()->getBetterReflection();
foreach ($this->getDeclaringClasses($reflection) as $lowercaseName => $declaringClass) {
// a built-in class is read from a stub, which one depends on the source locator that
// reflected it first; it changes only with PHP, its extensions or PHPStan itself
$fileName = $declaringClass->isInternal() ? null : $declaringClass->getFileName();
$declarations[$lowercaseName] = $fileName === null
? 'built-in'
: sprintf('%s %s', $fileName, $this->getExportedNode($fileName, $declaringClass->getName()));
}
ksort($declarations);
return hash('sha256', implode("\n", $declarations));
}
/**
* The class with its parents, interfaces and traits. ClassReflection::getAncestors() would also
* resolve their generic types from the class PHPDocs, reaching StubPhpDocProvider - which runs
* the StubFilesExtensions, while the result cache is restored before the bootstrapFiles they
* can rely on.
*
* @return array<string, ReflectionClass> lowercase name => class
*/
private function getDeclaringClasses(ReflectionClass $reflection): array
{
$classes = [];
$queue = [$reflection];
while ($queue !== []) {
$class = array_pop($queue);
$lowercaseName = strtolower($class->getName());
if (array_key_exists($lowercaseName, $classes)) {
continue;
}
$classes[$lowercaseName] = $class;
foreach ($class->getImmediateInterfaces() as $interface) {
$queue[] = $interface;
}
foreach ($class->getTraits() as $trait) {
$queue[] = $trait;
}
$parentClass = $class->getParentClass();
if ($parentClass === null) {
continue;
}
$queue[] = $parentClass;
}
return $classes;
}
public function keyToResultCache(string $key): string
{
return $key;
}
public function keyFromResultCache(string $storedKey): string
{
return $storedKey;
}
private function getExportedNode(string $fileName, string $className): string
{
$signature = $this->fileContentHasher->hash($fileName);
if ($signature === false) {
return 'missing file';
}
if (!array_key_exists($fileName, $this->exportedNodesByFile) || $this->exportedNodesByFile[$fileName][0] !== $signature) {
$nodes = [];
foreach ($this->exportedNodeFetcher->fetchNodes($fileName) as $node) {
$nodes[strtolower($node->getName())] = json_encode($node) ?: '';
}
$this->exportedNodesByFile[$fileName] = [$signature, $nodes];
}
return $this->exportedNodesByFile[$fileName][1][strtolower($className)] ?? 'not exported';
}
}