Skip to content

Commit 1f4d9c3

Browse files
malsukemalsuke
authored
Improve preg_split() function return type
1 parent c8716d6 commit 1f4d9c3

File tree

4 files changed

+243
-19
lines changed

4 files changed

+243
-19
lines changed

‎resources/functionMap.php‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8726,7 +8726,7 @@
87268726
'preg_replace' => ['string|array|null', 'regex'=>'string|array', 'replace'=>'string|array', 'subject'=>'string|array', 'limit='=>'int', '&w_count='=>'int'],
87278727
'preg_replace_callback' => ['string|array|null', 'regex'=>'string|array', 'callback'=>'callable(array<int|string, string>):string', 'subject'=>'string|array', 'limit='=>'int', '&w_count='=>'int'],
87288728
'preg_replace_callback_array' => ['string|array|null', 'pattern'=>'array<string,callable>', 'subject'=>'string|array', 'limit='=>'int', '&w_count='=>'int'],
8729-
'preg_split' => ['list<string>|false', 'pattern'=>'string', 'subject'=>'string', 'limit='=>'?int', 'flags='=>'int'],
8729+
'preg_split' => ['list<string>|list<array{string, int<0, max>}>|false', 'pattern'=>'string', 'subject'=>'string', 'limit='=>'?int', 'flags='=>'int'],
87308730
'prev' => ['mixed', '&rw_array_arg'=>'array|object'],
87318731
'print_r' => ['string|true', 'var'=>'mixed', 'return='=>'bool'],
87328732
'printf' => ['int', 'format'=>'string', '...values='=>'__stringAndStringable|int|float|null|bool'],

‎src/Type/Php/PregSplitDynamicReturnTypeExtension.php‎

Lines changed: 169 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,29 +2,41 @@
22

33
namespace PHPStan\Type\Php;
44

5+
use Nette\Utils\RegexpException;
6+
use Nette\Utils\Strings;
57
use PhpParser\Node\Expr\FuncCall;
68
use PHPStan\Analyser\Scope;
79
use PHPStan\Reflection\FunctionReflection;
8-
use PHPStan\TrinaryLogic;
910
use PHPStan\Type\Accessory\AccessoryArrayListType;
11+
use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
12+
use PHPStan\Type\Accessory\NonEmptyArrayType;
1013
use PHPStan\Type\ArrayType;
1114
use PHPStan\Type\BitwiseFlagHelper;
12-
use PHPStan\Type\Constant\ConstantArrayType;
15+
use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
1316
use PHPStan\Type\Constant\ConstantBooleanType;
1417
use PHPStan\Type\Constant\ConstantIntegerType;
18+
use PHPStan\Type\Constant\ConstantStringType;
1519
use PHPStan\Type\DynamicFunctionReturnTypeExtension;
20+
use PHPStan\Type\ErrorType;
1621
use PHPStan\Type\IntegerRangeType;
1722
use PHPStan\Type\IntegerType;
23+
use PHPStan\Type\MixedType;
1824
use PHPStan\Type\StringType;
1925
use PHPStan\Type\Type;
2026
use PHPStan\Type\TypeCombinator;
27+
use PHPStan\Type\UnionType;
28+
use function count;
29+
use function is_array;
30+
use function is_int;
31+
use function is_numeric;
32+
use function preg_split;
2133
use function strtolower;
2234

2335
final class PregSplitDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
2436
{
2537

2638
public function __construct(
27-
private BitwiseFlagHelper $bitwiseFlagAnalyser,
39+
private readonly BitwiseFlagHelper $bitwiseFlagAnalyser,
2840
)
2941
{
3042
}
@@ -36,17 +48,164 @@ public function isFunctionSupported(FunctionReflection $functionReflection): boo
3648

3749
public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): ?Type
3850
{
39-
$flagsArg = $functionCall->getArgs()[3] ?? null;
51+
$args = $functionCall->getArgs();
52+
if (count($args) < 2) {
53+
return null;
54+
}
55+
$patternArg = $args[0];
56+
$subjectArg = $args[1];
57+
$limitArg = $args[2] ?? null;
58+
$capturesOffset = $args[3] ?? null;
59+
$patternType = $scope->getType($patternArg->value);
60+
$patternConstantTypes = $patternType->getConstantStrings();
61+
if (count($patternConstantTypes) > 0) {
62+
foreach ($patternConstantTypes as $patternConstantType) {
63+
if ($this->isValidPattern($patternConstantType->getValue()) === false) {
64+
return new ErrorType();
65+
}
66+
}
67+
}
68+
69+
$subjectType = $scope->getType($subjectArg->value);
70+
$subjectConstantTypes = $subjectType->getConstantStrings();
71+
72+
$limits = [];
73+
if ($limitArg === null) {
74+
$limits = [-1];
75+
} else {
76+
$limitType = $scope->getType($limitArg->value);
77+
if (!$this->isIntOrStringValue($limitType)) {
78+
return new ErrorType();
79+
}
80+
foreach ($limitType->getConstantScalarValues() as $limit) {
81+
if (!is_int($limit) && !is_numeric($limit)) {
82+
return new ErrorType();
83+
}
84+
$limits[] = $limit;
85+
}
86+
}
87+
88+
$flags = [];
89+
if ($capturesOffset === null) {
90+
$flags = [0];
91+
} else {
92+
$flagType = $scope->getType($capturesOffset->value);
93+
if (!$this->isIntOrStringValue($flagType)) {
94+
return new ErrorType();
95+
}
96+
foreach ($flagType->getConstantScalarValues() as $flag) {
97+
if (!is_int($flag) && !is_numeric($flag)) {
98+
return new ErrorType();
99+
}
100+
$flags[] = $flag;
101+
}
102+
}
40103

41-
if ($flagsArg !== null && $this->bitwiseFlagAnalyser->bitwiseOrContainsConstant($flagsArg->value, $scope, 'PREG_SPLIT_OFFSET_CAPTURE')->yes()) {
42-
$type = new ArrayType(
43-
new IntegerType(),
44-
new ConstantArrayType([new ConstantIntegerType(0), new ConstantIntegerType(1)], [new StringType(), IntegerRangeType::fromInterval(0, null)], [2], [], TrinaryLogic::createYes()),
104+
if ($this->isPatternOrSubjectEmpty($patternConstantTypes, $subjectConstantTypes)) {
105+
if ($capturesOffset !== null
106+
&& $this->bitwiseFlagAnalyser->bitwiseOrContainsConstant($capturesOffset->value, $scope, 'PREG_SPLIT_NO_EMPTY')->yes()) {
107+
$returnStringType = TypeCombinator::intersect(
108+
new StringType(),
109+
new AccessoryNonEmptyStringType(),
110+
);
111+
} else {
112+
$returnStringType = new StringType();
113+
}
114+
115+
$arrayTypeBuilder = ConstantArrayTypeBuilder::createEmpty();
116+
$arrayTypeBuilder->setOffsetValueType(
117+
new ConstantIntegerType(0),
118+
$returnStringType,
119+
);
120+
$arrayTypeBuilder->setOffsetValueType(
121+
new ConstantIntegerType(1),
122+
IntegerRangeType::fromInterval(0, null),
45123
);
46-
return TypeCombinator::union(TypeCombinator::intersect($type, new AccessoryArrayListType()), new ConstantBooleanType(false));
124+
$capturedArrayType = $arrayTypeBuilder->getArray();
125+
126+
$returnInternalValueType = $returnStringType;
127+
if ($capturesOffset !== null) {
128+
$flagState = $this->bitwiseFlagAnalyser->bitwiseOrContainsConstant($capturesOffset->value, $scope, 'PREG_SPLIT_OFFSET_CAPTURE');
129+
if ($flagState->yes()) {
130+
$capturedArrayListType = TypeCombinator::intersect(
131+
new ArrayType(new IntegerType(), $capturedArrayType),
132+
new AccessoryArrayListType(),
133+
);
134+
135+
if ($subjectType->isNonEmptyString()->yes()) {
136+
$capturedArrayListType = TypeCombinator::intersect($capturedArrayListType, new NonEmptyArrayType());
137+
}
138+
return TypeCombinator::union($capturedArrayListType, new ConstantBooleanType(false));
139+
}
140+
if ($flagState->maybe()) {
141+
$returnInternalValueType = TypeCombinator::union(new StringType(), $capturedArrayType);
142+
}
143+
}
144+
145+
$returnListType = TypeCombinator::intersect(new ArrayType(new MixedType(), $returnInternalValueType), new AccessoryArrayListType());
146+
if ($subjectType->isNonEmptyString()->yes()) {
147+
$returnListType = TypeCombinator::intersect(
148+
$returnListType,
149+
new NonEmptyArrayType(),
150+
);
151+
}
152+
153+
return TypeCombinator::union($returnListType, new ConstantBooleanType(false));
47154
}
48155

49-
return null;
156+
$resultTypes = [];
157+
foreach ($patternConstantTypes as $patternConstantType) {
158+
foreach ($subjectConstantTypes as $subjectConstantType) {
159+
foreach ($limits as $limit) {
160+
foreach ($flags as $flag) {
161+
$result = @preg_split($patternConstantType->getValue(), $subjectConstantType->getValue(), (int) $limit, (int) $flag);
162+
if ($result === false) {
163+
return new ErrorType();
164+
}
165+
$constantArray = ConstantArrayTypeBuilder::createEmpty();
166+
foreach ($result as $key => $value) {
167+
if (is_array($value)) {
168+
$valueConstantArray = ConstantArrayTypeBuilder::createEmpty();
169+
$valueConstantArray->setOffsetValueType(new ConstantIntegerType(0), new ConstantStringType($value[0]));
170+
$valueConstantArray->setOffsetValueType(new ConstantIntegerType(1), new ConstantIntegerType($value[1]));
171+
$returnInternalValueType = $valueConstantArray->getArray();
172+
} else {
173+
$returnInternalValueType = new ConstantStringType($value);
174+
}
175+
$constantArray->setOffsetValueType(new ConstantIntegerType($key), $returnInternalValueType);
176+
}
177+
178+
$resultTypes[] = $constantArray->getArray();
179+
}
180+
}
181+
}
182+
}
183+
$resultTypes[] = new ConstantBooleanType(false);
184+
return TypeCombinator::union(...$resultTypes);
185+
}
186+
187+
/**
188+
* @param ConstantStringType[] $patternConstantArray
189+
* @param ConstantStringType[] $subjectConstantArray
190+
*/
191+
private function isPatternOrSubjectEmpty(array $patternConstantArray, array $subjectConstantArray): bool
192+
{
193+
return count($patternConstantArray) === 0 || count($subjectConstantArray) === 0;
194+
}
195+
196+
private function isValidPattern(string $pattern): bool
197+
{
198+
try {
199+
Strings::match('', $pattern);
200+
} catch (RegexpException) {
201+
return false;
202+
}
203+
return true;
204+
}
205+
206+
private function isIntOrStringValue(Type $type): bool
207+
{
208+
return (new UnionType([new IntegerType(), new StringType()]))->isSuperTypeOf($type)->yes();
50209
}
51210

52211
}

‎tests/PHPStan/Analyser/AnalyserIntegrationTest.php‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -936,7 +936,7 @@ public function testBug7554(): void
936936
$this->assertSame(sprintf('Parameter #1 $%s of function count expects array|Countable, list<array<int, int<0, max>|string>>|false given.', PHP_VERSION_ID < 80000 ? 'var' : 'value'), $errors[0]->getMessage());
937937
$this->assertSame(26, $errors[0]->getLine());
938938

939-
$this->assertSame('Cannot access offset int<1, max> on list<array{string, int<0, max>}>|false.', $errors[1]->getMessage());
939+
$this->assertSame('Cannot access offset int<1, max> on list<array{non-empty-string, int<0, max>}>|false.', $errors[1]->getMessage());
940940
$this->assertSame(27, $errors[1]->getLine());
941941
}
942942

‎tests/PHPStan/Analyser/nsrt/preg_split.php‎

Lines changed: 72 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,77 @@
66

77
class HelloWorld
88
{
9+
private const NUMERIC_STRING_1 = "1";
10+
private const NUMERIC_STRING_NEGATIVE_1 = "-1";
11+
912
public function doFoo()
1013
{
11-
assertType('list<string>|false', preg_split('/-/', '1-2-3'));
12-
assertType('list<string>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY));
13-
assertType('list<array{string, int<0, max>}>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_OFFSET_CAPTURE));
14-
assertType('list<array{string, int<0, max>}>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
14+
assertType("array{''}|false", preg_split('/-/', ''));
15+
assertType("array{}|false", preg_split('/-/', '', -1, PREG_SPLIT_NO_EMPTY));
16+
assertType("array{'1', '-', '2', '-', '3'}|false", preg_split('/ *(-) */', '1- 2-3', -1, PREG_SPLIT_DELIM_CAPTURE));
17+
assertType("array{array{'', 0}}|false", preg_split('/-/', '', -1, PREG_SPLIT_OFFSET_CAPTURE));
18+
assertType("array{}|false", preg_split('/-/', '', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
19+
assertType("array{'1', '2', '3'}|false", preg_split('/-/', '1-2-3'));
20+
assertType("array{'1', '2', '3'}|false", preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY));
21+
assertType("array{'1', '3'}|false", preg_split('/-/', '1--3', -1, PREG_SPLIT_NO_EMPTY));
22+
assertType("array{array{'1', 0}, array{'2', 2}, array{'3', 4}}|false", preg_split('/-/', '1-2-3', -1, PREG_SPLIT_OFFSET_CAPTURE));
23+
assertType("array{array{'1', 0}, array{'2', 2}, array{'3', 4}}|false", preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
24+
assertType("array{array{'1', 0}, array{'', 2}, array{'3', 3}}|false", preg_split('/-/', '1--3', -1, PREG_SPLIT_OFFSET_CAPTURE));
25+
assertType("array{array{'1', 0}, array{'3', 3}}|false", preg_split('/-/', '1--3', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
26+
27+
assertType("array{'1', '2', '3'}|false", preg_split('/-/', '1-2-3', self::NUMERIC_STRING_NEGATIVE_1));
28+
assertType("array{'1', '2', '3'}|false", preg_split('/-/', '1-2-3', -1, self::NUMERIC_STRING_1));
29+
}
30+
31+
public function doWithError() {
32+
assertType('*ERROR*', preg_split('/[0-9a]', '1-2-3'));
33+
assertType('*ERROR*', preg_split('/-/', '1-2-3', 'hogehoge'));
34+
assertType('*ERROR*', preg_split('/-/', '1-2-3', -1, 'hogehoge'));
35+
assertType('*ERROR*', preg_split('/-/', '1-2-3', [], self::NUMERIC_STRING_NEGATIVE_1));
36+
assertType('*ERROR*', preg_split('/-/', '1-2-3', null, self::NUMERIC_STRING_NEGATIVE_1));
37+
assertType('*ERROR*', preg_split('/-/', '1-2-3', -1, []));
38+
assertType('*ERROR*', preg_split('/-/', '1-2-3', -1, null));
39+
}
40+
41+
public function doWithVariables(string $pattern, string $subject, int $offset, int $flags): void
42+
{
43+
assertType("array{'1', '2', '3'}|array{'1-2-3'}|false", preg_split('/-/', '1-2-3', $this->generate()));
44+
assertType("array{'1', '2', '3'}|array{'1-2-3'}|false", preg_split('/-/', '1-2-3', $this->generate(), $this->generate()));
45+
46+
assertType('list<array{string, int<0, max>}|string>|false', preg_split($pattern, $subject, $offset, $flags));
47+
assertType('list<array{string, int<0, max>}|string>|false', preg_split("//", $subject, $offset, $flags));
48+
49+
assertType('non-empty-list<array{string, int<0, max>}|string>|false', preg_split($pattern, "1-2-3", $offset, $flags));
50+
assertType('list<array{string, int<0, max>}|string>|false', preg_split($pattern, $subject, -1, $flags));
51+
assertType('list<non-empty-string>|false', preg_split($pattern, $subject, $offset, PREG_SPLIT_NO_EMPTY));
52+
assertType('list<array{string, int<0, max>}>|false', preg_split($pattern, $subject, $offset, PREG_SPLIT_OFFSET_CAPTURE));
53+
assertType("list<string>|false", preg_split($pattern, $subject, $offset, PREG_SPLIT_DELIM_CAPTURE));
54+
assertType('list<array{string, int<0, max>}>|false', preg_split($pattern, $subject, $offset, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE));
55+
}
56+
57+
/**
58+
* @return 1|'17'
59+
*/
60+
private function generate(): int|string {
61+
return (rand() % 2 === 0) ? 1 : "17";
62+
}
63+
64+
/**
65+
* @param non-empty-string $nonEmptySubject
66+
*/
67+
public function doWithNonEmptySubject(string $pattern, string $nonEmptySubject, int $offset, int $flags): void
68+
{
69+
assertType('non-empty-list<string>|false', preg_split("//", $nonEmptySubject));
70+
71+
assertType('non-empty-list<array{string, int<0, max>}|string>|false', preg_split($pattern, $nonEmptySubject, $offset, $flags));
72+
assertType('non-empty-list<array{string, int<0, max>}|string>|false', preg_split("//", $nonEmptySubject, $offset, $flags));
73+
74+
assertType('non-empty-list<array{string, int<0, max>}>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_OFFSET_CAPTURE));
75+
assertType('non-empty-list<non-empty-string>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_NO_EMPTY));
76+
assertType('non-empty-list<string>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_DELIM_CAPTURE));
77+
assertType('non-empty-list<array{string, int<0, max>}>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE));
78+
assertType('non-empty-list<array{non-empty-string, int<0, max>}>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
79+
assertType('non-empty-list<non-empty-string>|false', preg_split("/-/", $nonEmptySubject, $offset, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE));
1580
}
1681

1782
/**
@@ -26,16 +91,16 @@ public static function splitWithOffset($pattern, $subject, $limit = -1, $flags =
2691
{
2792
assertType('list<array{string, int<0, max>}>|false', preg_split($pattern, $subject, $limit, $flags | PREG_SPLIT_OFFSET_CAPTURE));
2893
assertType('list<array{string, int<0, max>}>|false', preg_split($pattern, $subject, $limit, PREG_SPLIT_OFFSET_CAPTURE | $flags));
29-
30-
assertType('list<array{string, int<0, max>}>|false', preg_split($pattern, $subject, $limit, PREG_SPLIT_OFFSET_CAPTURE | $flags | PREG_SPLIT_NO_EMPTY));
94+
assertType('list<array{non-empty-string, int<0, max>}>|false', preg_split($pattern, $subject, $limit, PREG_SPLIT_OFFSET_CAPTURE | $flags | PREG_SPLIT_NO_EMPTY));
3195
}
3296

3397
/**
3498
* @param string $pattern
3599
* @param string $subject
36100
* @param int $limit
37101
*/
38-
public static function dynamicFlags($pattern, $subject, $limit = -1) {
102+
public static function dynamicFlags($pattern, $subject, $limit = -1)
103+
{
39104
$flags = PREG_SPLIT_OFFSET_CAPTURE;
40105

41106
if ($subject === '1-2-3') {

0 commit comments

Comments
 (0)