Specfiy root expression from type specifying extensions

Author: herndlm

src/Analyser/TypeSpecifier.php

@@ -691,7 +691,7 @@ public function specifyTypesInCondition(
 						continue;
 					}
 
-					return $extension->specifyTypes($functionReflection, $expr, $scope, $context);
+					return $this->specifyRootExpr($extension->specifyTypes($functionReflection, $expr, $scope, $context), $scope, $context);
 				}
 
 				if (count($expr->getArgs()) > 0) {
@@ -719,7 +719,7 @@ public function specifyTypesInCondition(
 							continue;
 						}
 
-						return $extension->specifyTypes($methodReflection, $expr, $scope, $context);
+						return $this->specifyRootExpr($extension->specifyTypes($methodReflection, $expr, $scope, $context), $scope, $context);
 					}
 
 					if (count($expr->getArgs()) > 0) {
@@ -753,7 +753,7 @@ public function specifyTypesInCondition(
 							continue;
 						}
 
-						return $extension->specifyTypes($staticMethodReflection, $expr, $scope, $context);
+						return $this->specifyRootExpr($extension->specifyTypes($staticMethodReflection, $expr, $scope, $context), $scope, $context);
 					}
 				}
 
@@ -1421,4 +1421,21 @@ private function getTypeSpecifyingExtensionsForType(array $extensions, string $c
 		return array_merge(...$extensionsForClass);
 	}
 
+	private function specifyRootExpr(SpecifiedTypes $specifiedTypes, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
+	{
+		$rootExpr = $specifiedTypes->getRootExpr();
+		if ($rootExpr === null || $context->null()) {
+			return $specifiedTypes;
+		}
+
+		$rootExprType = $scope->getType($rootExpr);
+		if (!$rootExprType instanceof BooleanType || $rootExprType instanceof ConstantBooleanType) {
+			return $specifiedTypes;
+		}
+
+		return $specifiedTypes->unionWith(
+			$this->create($rootExpr, new ConstantBooleanType(true), $context),
+		);
+	}
+
 }

src/Type/Php/StrContainingTypeSpecifyingExtension.php

@@ -2,7 +2,6 @@
 
 namespace PHPStan\Type\Php;
 
-use PhpParser\Node\Arg;
 use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
 use PhpParser\Node\Expr\BinaryOp\NotIdentical;
 use PhpParser\Node\Expr\FuncCall;
@@ -27,17 +26,17 @@
 final class StrContainingTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
 {
 
-	/** @var array<string, array{0: int, 1: int}> */
+	/** @var array<string, array{0: int, 1: int, 2: bool}> */
 	private array $strContainingFunctions = [
-		'fnmatch' => [1, 0],
-		'str_contains' => [0, 1],
-		'str_starts_with' => [0, 1],
-		'str_ends_with' => [0, 1],
-		'strpos' => [0, 1],
-		'strrpos' => [0, 1],
-		'stripos' => [0, 1],
-		'strripos' => [0, 1],
-		'strstr' => [0, 1],
+		'fnmatch' => [1, 0, true],
+		'str_contains' => [0, 1, true],
+		'str_starts_with' => [0, 1, true],
+		'str_ends_with' => [0, 1, true],
+		'strpos' => [0, 1, false],
+		'strrpos' => [0, 1, false],
+		'stripos' => [0, 1, false],
+		'strripos' => [0, 1, false],
+		'strstr' => [0, 1, false],
 	];
 
 	private TypeSpecifier $typeSpecifier;
@@ -58,7 +57,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		$args = $node->getArgs();
 
 		if (count($args) >= 2) {
-			[$hackstackArg, $needleArg] = $this->strContainingFunctions[strtolower($functionReflection->getName())];
+			[$hackstackArg, $needleArg, $evaluatesToBoolean] = $this->strContainingFunctions[strtolower($functionReflection->getName())];
 
 			$haystackType = $scope->getType($args[$hackstackArg]->value);
 			$needleType = $scope->getType($args[$needleArg]->value);
@@ -76,21 +75,23 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 					$accessories[] = new AccessoryNumericStringType();
 				}
 
+				$rootExpr = $evaluatesToBoolean
+					? new BooleanAnd(
+						new NotIdentical(
+							$args[$needleArg]->value,
+							new String_(''),
+						),
+						new FuncCall(new Name('FAUX_FUNCTION_' . $functionReflection->getName()), $args),
+					)
+					: new FuncCall(new Name('FAUX_FUNCTION_' . $functionReflection->getName()), $args);
+
 				return $this->typeSpecifier->create(
 					$args[$hackstackArg]->value,
 					new IntersectionType($accessories),
 					$context,
 					false,
 					$scope,
-					new BooleanAnd(
-						new NotIdentical(
-							$args[$needleArg]->value,
-							new String_(''),
-						),
-						new FuncCall(new Name('FAUX_FUNCTION'), [
-							new Arg($args[$needleArg]->value),
-						]),
-					),
+					$rootExpr,
 				);
 			}
 		}

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -532,7 +532,16 @@ public function testNonEmptySpecifiedString(): void
 	{
 		$this->checkAlwaysTrueCheckTypeFunctionCall = true;
 		$this->treatPhpDocTypesAsCertain = true;
-		$this->analyse([__DIR__ . '/data/non-empty-string-impossible-type.php'], []);
+		$this->analyse([__DIR__ . '/data/non-empty-string-impossible-type.php'], [
+			[
+				'Call to function str_contains() with non-empty-string and \'foo\' will always evaluate to true.',
+				26,
+			],
+			[
+				'Call to function str_contains() with non-empty-string and \'foo\' will always evaluate to true.',
+				36,
+			],
+		]);
 	}
 
 	public function testBug2755(): void

tests/PHPStan/Rules/Comparison/data/non-empty-string-impossible-type.php

@@ -19,4 +19,30 @@ private function isPrefixedInterface(string $shortClassName): bool
 
 		return ctype_lower($shortClassName[2]);
 	}
+
+	public function strContains(string $a, string $b, string $c, string $d, string $e): void
+	{
+		if (str_contains($a, 'foo')) {
+			if (str_contains($a, 'foo')) {
+			}
+		}
+
+		if (!str_contains($b, 'foo')) {
+			if (!str_contains($b, 'foo')) {
+			}
+		}
+
+		if (str_contains($c, 'foo')) {
+			if (!str_contains($c, 'foo')) {
+			}
+		}
+
+		if (!str_contains($d, 'foo')) {
+			if (str_contains($d, 'foo')) {
+			}
+		}
+
+		if (str_contains($e, 'bar')) {
+		}
+	}
 }