Implement PregGrepDynamicReturnTypeExtension

conf/config.neon

@@ -1716,6 +1716,14 @@ services:
 		tags:
 			- phpstan.broker.dynamicStaticMethodReturnTypeExtension
 
+	-
+		class: PHPStan\Type\Php\PregMatchingDynamicReturnTypeExtension
+		tags:
+			- phpstan.broker.dynamicFunctionReturnTypeExtension
+
+	-
+		class: PHPStan\Rules\Regexp\RegularExpressionHelper
+
 	-
 		class: PHPStan\Type\ClosureTypeFactory
 		arguments:

src/Rules/Regexp/RegularExpressionHelper.php

@@ -0,0 +1,22 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Regexp;
+
+use Nette\Utils\RegexpException;
+use Nette\Utils\Strings;
+
+final class RegularExpressionHelper
+{
+
+	public function validatePattern(string $pattern): ?string
+	{
+		try {
+			Strings::match('', $pattern);
+		} catch (RegexpException $e) {
+			return $e->getMessage();
+		}
+
+		return null;
+	}
+
+}

src/Rules/Regexp/RegularExpressionPatternRule.php

@@ -2,8 +2,6 @@
 
 namespace PHPStan\Rules\Regexp;
 
-use Nette\Utils\RegexpException;
-use Nette\Utils\Strings;
 use PhpParser\Node;
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
@@ -20,6 +18,12 @@
 class RegularExpressionPatternRule implements Rule
 {
 
+	public function __construct(
+		private RegularExpressionHelper $regularExpressionHelper,
+	)
+	{
+	}
+
 	public function getNodeType(): string
 	{
 		return FuncCall::class;
@@ -31,7 +35,7 @@ public function processNode(Node $node, Scope $scope): array
 
 		$errors = [];
 		foreach ($patterns as $pattern) {
-			$errorMessage = $this->validatePattern($pattern);
+			$errorMessage = $this->regularExpressionHelper->validatePattern($pattern);
 			if ($errorMessage === null) {
 				continue;
 			}
@@ -110,15 +114,4 @@ private function extractPatterns(FuncCall $functionCall, Scope $scope): array
 		return $patternStrings;
 	}
 
-	private function validatePattern(string $pattern): ?string
-	{
-		try {
-			Strings::match('', $pattern);
-		} catch (RegexpException $e) {
-			return $e->getMessage();
-		}
-
-		return null;
-	}
-
 }

src/Type/Php/PregMatchingDynamicReturnTypeExtension.php

@@ -0,0 +1,59 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Php;
+
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Rules\Regexp\RegularExpressionHelper;
+use PHPStan\Type\Constant\ConstantBooleanType;
+use PHPStan\Type\DynamicFunctionReturnTypeExtension;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function count;
+use function in_array;
+use function strtolower;
+
+class PregMatchingDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
+{
+
+	public function __construct(
+		private RegularExpressionHelper $regularExpressionHelper,
+	)
+	{
+	}
+
+	public function isFunctionSupported(FunctionReflection $functionReflection): bool
+	{
+		return in_array(strtolower($functionReflection->getName()), ['preg_grep', 'preg_match', 'preg_match_all'], true);
+	}
+
+	public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): ?Type
+	{
+		$args = $functionCall->getArgs();
+		if (count($args) < 1) {
+			return null;
+		}
+
+		$patternType = $scope->getType($args[0]->value);
+		$constantStrings = $patternType->getConstantStrings();
+		if (count($constantStrings) === 0) {
+			return null;
+		}
+
+		foreach ($constantStrings as $constantString) {
+			if ($this->regularExpressionHelper->validatePattern($constantString->getValue()) !== null) {
+				return null;
+			}
+		}
+
+		$defaultReturn = ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
+
+		return TypeCombinator::remove(
+			$defaultReturn,
+			new ConstantBooleanType(false),
+		);
+	}
+
+}

src/Type/Php/PregSplitDynamicReturnTypeExtension.php

@@ -6,6 +6,7 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Rules\Regexp\RegularExpressionHelper;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\ArrayType;
@@ -19,13 +20,15 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use function count;
 use function strtolower;
 
 class PregSplitDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
 
 	public function __construct(
 		private BitwiseFlagHelper $bitwiseFlagAnalyser,
+		private RegularExpressionHelper $regularExpressionHelper,
 	)
 	{
 	}
@@ -44,10 +47,32 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 				new IntegerType(),
 				new ConstantArrayType([new ConstantIntegerType(0), new ConstantIntegerType(1)], [new StringType(), IntegerRangeType::fromInterval(0, null)], [2], [], TrinaryLogic::createYes()),
 			);
-			return TypeCombinator::union(AccessoryArrayListType::intersectWith($type), new ConstantBooleanType(false));
+			$returnType = TypeCombinator::union(AccessoryArrayListType::intersectWith($type), new ConstantBooleanType(false));
+		} else {
+			$returnType = ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
 		}
 
-		return ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
+		$patternArg = $functionCall->getArgs()[0] ?? null;
+		if ($patternArg === null) {
+			return $returnType;
+		}
+
+		$patternType = $scope->getType($patternArg->value);
+		$constantStrings = $patternType->getConstantStrings();
+		if (count($constantStrings) === 0) {
+			return $returnType;
+		}
+
+		foreach ($constantStrings as $constantString) {
+			if ($this->regularExpressionHelper->validatePattern($constantString->getValue()) !== null) {
+				return $returnType;
+			}
+		}
+
+		return TypeCombinator::remove(
+			$returnType,
+			new ConstantBooleanType(false),
+		);
 	}
 
 }

tests/PHPStan/Analyser/AnalyserIntegrationTest.php

@@ -15,7 +15,6 @@
 use PHPStan\Type\Constant\ConstantStringType;
 use function extension_loaded;
 use function restore_error_handler;
-use function sprintf;
 use const PHP_VERSION_ID;
 
 class AnalyserIntegrationTest extends PHPStanTestCase
@@ -835,13 +834,11 @@ public function testOffsetAccess(): void
 	public function testUnresolvableParameter(): void
 	{
 		$errors = $this->runAnalyse(__DIR__ . '/data/unresolvable-parameter.php');
-		$this->assertCount(3, $errors);
-		$this->assertSame('Parameter #2 $array of function array_map expects array, array<int, string>|false given.', $errors[0]->getMessage());
-		$this->assertSame(18, $errors[0]->getLine());
-		$this->assertSame('Method UnresolvableParameter\Collection::pipeInto() has parameter $class with no type specified.', $errors[1]->getMessage());
+		$this->assertCount(2, $errors);
+		$this->assertSame('Method UnresolvableParameter\Collection::pipeInto() has parameter $class with no type specified.', $errors[0]->getMessage());
+		$this->assertSame(30, $errors[0]->getLine());
+		$this->assertSame('PHPDoc tag @param for parameter $class contains unresolvable type.', $errors[1]->getMessage());
 		$this->assertSame(30, $errors[1]->getLine());
-		$this->assertSame('PHPDoc tag @param for parameter $class contains unresolvable type.', $errors[2]->getMessage());
-		$this->assertSame(30, $errors[2]->getLine());
 	}
 
 	public function testBug7248(): void
@@ -883,13 +880,7 @@ public function testBug7500(): void
 	public function testBug7554(): void
 	{
 		$errors = $this->runAnalyse(__DIR__ . '/data/bug-7554.php');
-		$this->assertCount(2, $errors);
-
-		$this->assertSame(sprintf('Parameter #1 $%s of function count expects array|Countable, array<int, array<int, int|string>>|false given.', PHP_VERSION_ID < 80000 ? 'var' : 'value'), $errors[0]->getMessage());
-		$this->assertSame(26, $errors[0]->getLine());
-
-		$this->assertSame('Cannot access offset int<1, max> on list<array{string, int<0, max>}>|false.', $errors[1]->getMessage());
-		$this->assertSame(27, $errors[1]->getLine());
+		$this->assertNoErrors($errors);
 	}
 
 	public function testBug7637(): void

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -1325,6 +1325,11 @@ public function dataFileAsserts(): iterable
 			yield from $this->gatherAssertTypes(__DIR__ . '/data/trigger-error-php7.php');
 		}
 
+		if (PHP_VERSION_ID >= 80000) {
+			yield from $this->gatherAssertTypes(__DIR__ . '/data/preg_matching_php8.php');
+		} else {
+			yield from $this->gatherAssertTypes(__DIR__ . '/data/preg_matching_php7.php');
+		}
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-7915.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-9714.php');
 	}

tests/PHPStan/Analyser/data/preg_match_php7.php

@@ -6,7 +6,7 @@
 
 class Foo {
 	public function doFoo() {
-		assertType('0|1|false', preg_match('{}', ''));
-		assertType('int<0, max>|false|null', preg_match_all('{}', ''));
+		assertType('0|1', preg_match('{}', ''));
+		assertType('int<0, max>|null', preg_match_all('{}', ''));
 	}
 }

tests/PHPStan/Analyser/data/preg_match_php8.php

@@ -6,8 +6,8 @@
 
 class Foo {
 	public function doFoo() {
-		assertType('0|1|false', preg_match('{}', ''));
-		assertType('int<0, max>|false', preg_match_all('{}', ''));
+		assertType('0|1', preg_match('{}', ''));
+		assertType('int<0, max>', preg_match_all('{}', ''));
 
 	}
 }

tests/PHPStan/Analyser/data/preg_matching_php7.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace PregMatching;
+
+use function PHPStan\Testing\assertType;
+
+function compilablePattern(array $a) {
+	assertType('array', preg_grep('/^[0-9]+$/', $a));
+	assertType('0|1', preg_match('/^[0-9]+$/', $a));
+	assertType('int<0, max>|null', preg_match_all('/^[0-9]+$/', $a));
+	assertType('list<string>', preg_split('/^[0-9]+$/', $a));
+}
+
+function bogusPattern(array $a) {
+	assertType('array|false', preg_grep('/bogus-pattern-[0^-9]$/', $a));
+	assertType('0|1|false', preg_match('/bogus-pattern-[0^-9]$/', $a));
+	assertType('int<0, max>|false|null', preg_match_all('/bogus-pattern-[0^-9]$/', $a));
+	assertType('list<string>|false', preg_split('/bogus-pattern-[0^-9]$/', $a));
+}
+
+function unknownPattern(string $p, array $a) {
+	assertType('array|false', preg_grep($p, $a));
+	assertType('0|1|false', preg_match($p, $a));
+	assertType('int<0, max>|false|null', preg_match_all($p, $a));
+	assertType('list<string>|false', preg_split($p, $a));
+}
+
+function sometimesCompilablePattern(array $a) {
+	$p = '/^[0-9]+$/';
+	if (rand(0,1)) {
+		$p = '/bogus-pattern-[0^-9]$/';
+	}
+	assertType('array|false', preg_grep($p, $a));
+	assertType('0|1|false', preg_match($p, $a));
+	assertType('int<0, max>|false|null', preg_match_all($p, $a));
+	assertType('list<string>|false', preg_split($p, $a));
+}

tests/PHPStan/Analyser/data/preg_matching_php8.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace PregMatching;
+
+use function PHPStan\Testing\assertType;
+
+function compilablePattern(array $a) {
+	assertType('array', preg_grep('/^[0-9]+$/', $a));
+	assertType('0|1', preg_match('/^[0-9]+$/', $a));
+	assertType('int<0, max>', preg_match_all('/^[0-9]+$/', $a));
+	assertType('list<string>', preg_split('/^[0-9]+$/', $a));
+}
+
+function bogusPattern(array $a) {
+	assertType('array|false', preg_grep('/bogus-pattern-[0^-9]$/', $a));
+	assertType('0|1|false', preg_match('/bogus-pattern-[0^-9]$/', $a));
+	assertType('int<0, max>|false', preg_match_all('/bogus-pattern-[0^-9]$/', $a));
+	assertType('list<string>|false', preg_split('/bogus-pattern-[0^-9]$/', $a));
+}
+
+function unknownPattern(string $p, array $a) {
+	assertType('array|false', preg_grep($p, $a));
+	assertType('0|1|false', preg_match($p, $a));
+	assertType('int<0, max>|false', preg_match_all($p, $a));
+	assertType('list<string>|false', preg_split($p, $a));
+}
+
+function sometimesCompilablePattern(array $a) {
+	$p = '/^[0-9]+$/';
+	if (rand(0,1)) {
+		$p = '/bogus-pattern-[0^-9]$/';
+	}
+	assertType('array|false', preg_grep($p, $a));
+	assertType('0|1|false', preg_match($p, $a));
+	assertType('int<0, max>|false', preg_match_all($p, $a));
+	assertType('list<string>|false', preg_split($p, $a));
+}

tests/PHPStan/Analyser/data/preg_split.php

@@ -8,10 +8,10 @@ class HelloWorld
 {
 	public function doFoo()
 	{
-		assertType('list<string>|false', preg_split('/-/', '1-2-3'));
-		assertType('list<string>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY));
-		assertType('list<array{string, int<0, max>}>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_OFFSET_CAPTURE));
-		assertType('list<array{string, int<0, max>}>|false', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
+		assertType('list<string>', preg_split('/-/', '1-2-3'));
+		assertType('list<string>', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY));
+		assertType('list<array{string, int<0, max>}>', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_OFFSET_CAPTURE));
+		assertType('list<array{string, int<0, max>}>', preg_split('/-/', '1-2-3', -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE));
 	}
 
 	/**

tests/PHPStan/Rules/Regexp/RegularExpressionPatternRuleTest.php

@@ -15,7 +15,7 @@ class RegularExpressionPatternRuleTest extends RuleTestCase
 
 	protected function getRule(): Rule
 	{
-		return new RegularExpressionPatternRule();
+		return new RegularExpressionPatternRule(new RegularExpressionHelper());
 	}
 
 	public function testValidRegexPatternBefore73(): void