-
Notifications
You must be signed in to change notification settings - Fork 447
/
ValidateIgnoredErrorsExtension.php
149 lines (129 loc) · 4.53 KB
/
ValidateIgnoredErrorsExtension.php
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
144
145
146
147
148
149
<?php declare(strict_types = 1);
namespace PHPStan\DependencyInjection;
use Hoa\Compiler\Llk\Llk;
use Hoa\File\Read;
use Nette\DI\CompilerExtension;
use Nette\Utils\RegexpException;
use Nette\Utils\Strings;
use PHPStan\Analyser\DirectConstantResolver;
use PHPStan\Analyser\DirectConstantResolverProvider;
use PHPStan\Analyser\NameScope;
use PHPStan\Command\IgnoredRegexValidator;
use PHPStan\PhpDoc\DirectTypeNodeResolverExtensionRegistryProvider;
use PHPStan\PhpDoc\TypeNodeResolver;
use PHPStan\PhpDoc\TypeNodeResolverExtensionRegistry;
use PHPStan\PhpDoc\TypeStringResolver;
use PHPStan\PhpDocParser\Lexer\Lexer;
use PHPStan\PhpDocParser\Parser\ConstExprParser;
use PHPStan\PhpDocParser\Parser\TypeParser;
use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider;
use PHPStan\Reflection\ReflectionProvider\DummyReflectionProvider;
use PHPStan\Reflection\ReflectionProviderStaticAccessor;
use PHPStan\Type\DirectTypeAliasResolverProvider;
use PHPStan\Type\Type;
use PHPStan\Type\TypeAliasResolver;
use function array_keys;
use function array_map;
use function count;
use function implode;
use function is_array;
use function sprintf;
class ValidateIgnoredErrorsExtension extends CompilerExtension
{
/**
* @throws InvalidIgnoredErrorPatternsException
*/
public function loadConfiguration(): void
{
$builder = $this->getContainerBuilder();
if (!$builder->parameters['__validate']) {
return;
}
$ignoreErrors = $builder->parameters['ignoreErrors'];
if (count($ignoreErrors) === 0) {
return;
}
/** @throws void */
$parser = Llk::load(new Read('hoa://Library/Regex/Grammar.pp'));
$reflectionProvider = new DummyReflectionProvider();
ReflectionProviderStaticAccessor::registerInstance($reflectionProvider);
$ignoredRegexValidator = new IgnoredRegexValidator(
$parser,
new TypeStringResolver(
new Lexer(),
new TypeParser(new ConstExprParser()),
new TypeNodeResolver(
new DirectTypeNodeResolverExtensionRegistryProvider(
new class implements TypeNodeResolverExtensionRegistry {
public function getExtensions(): array
{
return [];
}
},
),
new DirectReflectionProviderProvider($reflectionProvider),
new DirectTypeAliasResolverProvider(new class implements TypeAliasResolver {
public function hasTypeAlias(string $aliasName, ?string $classNameScope): bool
{
return false;
}
public function resolveTypeAlias(string $aliasName, NameScope $nameScope): ?Type
{
return null;
}
}),
new DirectConstantResolverProvider(new DirectConstantResolver($reflectionProvider, [])),
),
),
);
$errors = [];
foreach ($ignoreErrors as $ignoreError) {
try {
if (is_array($ignoreError)) {
if (isset($ignoreError['count'])) {
continue; // ignoreError coming from baseline will be correct
}
$ignoreMessage = $ignoreError['message'];
} else {
$ignoreMessage = $ignoreError;
}
Strings::match('', $ignoreMessage);
$validationResult = $ignoredRegexValidator->validate($ignoreMessage);
$ignoredTypes = $validationResult->getIgnoredTypes();
if (count($ignoredTypes) > 0) {
$errors[] = $this->createIgnoredTypesError($ignoreMessage, $ignoredTypes);
}
if ($validationResult->hasAnchorsInTheMiddle()) {
$errors[] = $this->createAnchorInTheMiddleError($ignoreMessage);
}
if ($validationResult->areAllErrorsIgnored()) {
$errors[] = sprintf("Ignored error %s has an unescaped '%s' which leads to ignoring all errors. Use '%s' instead.", $ignoreMessage, $validationResult->getWrongSequence(), $validationResult->getEscapedWrongSequence());
}
} catch (RegexpException $e) {
$errors[] = $e->getMessage();
}
}
if (count($errors) === 0) {
return;
}
throw new InvalidIgnoredErrorPatternsException($errors);
}
/**
* @param array<string, string> $ignoredTypes
*/
private function createIgnoredTypesError(string $regex, array $ignoredTypes): string
{
return sprintf(
"Ignored error %s has an unescaped '|' which leads to ignoring more errors than intended. Use '\\|' instead.\n%s",
$regex,
sprintf(
"It ignores all errors containing the following types:\n%s",
implode("\n", array_map(static fn (string $typeDescription): string => sprintf('* %s', $typeDescription), array_keys($ignoredTypes))),
),
);
}
private function createAnchorInTheMiddleError(string $regex): string
{
return sprintf("Ignored error %s has an unescaped anchor '$' in the middle. This leads to unintended behavior. Use '\\$' instead.", $regex);
}
}