Replace FAUX function call workarounds

src/Analyser/MutatingScope.php

@@ -3265,6 +3265,11 @@ public function filterByTruthyValue(Expr $expr): self
 		}
 
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition($this, $expr, TypeSpecifierContext::createTruthy());
+		if ($specifiedTypes->shouldSpecifyOnly()) {
+			$specifiedTypes = $specifiedTypes->unionWith(
+				$this->typeSpecifier->create($expr, new ConstantBooleanType(true), TypeSpecifierContext::createTrue(), $this),
+			);
+		}
 		$scope = $this->filterBySpecifiedTypes($specifiedTypes);
 		$this->truthyScopes[$exprString] = $scope;
 
@@ -3282,6 +3287,11 @@ public function filterByFalseyValue(Expr $expr): self
 		}
 
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition($this, $expr, TypeSpecifierContext::createFalsey());
+		if ($specifiedTypes->shouldSpecifyOnly()) {
+			$specifiedTypes = $specifiedTypes->unionWith(
+				$this->typeSpecifier->create($expr, new ConstantBooleanType(false), TypeSpecifierContext::createTrue(), $this),
+			);
+		}
 		$scope = $this->filterBySpecifiedTypes($specifiedTypes);
 		$this->falseyScopes[$exprString] = $scope;
 

src/Analyser/NodeScopeResolver.php

@@ -143,6 +143,7 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\ClosureType;
+use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\FileTypeMapper;
@@ -1143,11 +1144,24 @@ public function processStmtNode(
 				$this->callNodeCallback($nodeCallback, new NoopExpressionNode($stmt->expr, $hasAssign), $scope, $storage);
 			}
 			$scope = $result->getScope();
-			$scope = $scope->filterBySpecifiedTypes($this->typeSpecifier->specifyTypesInCondition(
+			$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition(
 				$scope,
 				$stmt->expr,
 				TypeSpecifierContext::createNull(),
-			));
+			);
+			$scope = $scope->filterBySpecifiedTypes($specifiedTypes);
+			if ($specifiedTypes->shouldSpecifyOnly()) {
+				// Statement counterpart of the specifyOnly handling in filterByTruthyValue():
+				// store the call's true result so a duplicate void assertion statement is
+				// reported as always-true. We overwrite directly (not via TypeSpecifier::create)
+				// because void calls have no return value to protect from the purity check.
+				$scope = $scope->filterBySpecifiedTypes(
+					(new SpecifiedTypes(
+						[$scope->getNodeKey($stmt->expr) => [$stmt->expr, new ConstantBooleanType(true)]],
+						[],
+					))->setAlwaysOverwriteTypes(),
+				);
+			}
 			$hasYield = $result->hasYield();
 			$throwPoints = $result->getThrowPoints();
 			$impurePoints = $result->getImpurePoints();

src/Analyser/SpecifiedTypes.php

@@ -13,6 +13,8 @@ final class SpecifiedTypes
 
 	private bool $overwrite = false;
 
+	private bool $specifyOnly = false;
+
 	/** @var array<string, ConditionalExpressionHolder[]> */
 	private array $newConditionalExpressionHolders = [];
 
@@ -51,19 +53,44 @@ public function setAlwaysOverwriteTypes(): self
 	{
 		$self = new self($this->sureTypes, $this->sureNotTypes);
 		$self->overwrite = true;
+		$self->specifyOnly = $this->specifyOnly;
 		$self->newConditionalExpressionHolders = $this->newConditionalExpressionHolders;
 		$self->rootExpr = $this->rootExpr;
 
 		return $self;
 	}
 
+	/**
+	 * Marks these SpecifiedTypes as only narrowing types, not determining
+	 * the check outcome. ImpossibleCheckTypeHelper will not use sureTypes
+	 * to report always-true/false for the check expression.
+	 *
+	 * @api
+	 */
+	public function setSpecifyOnly(): self
+	{
+		$self = new self($this->sureTypes, $this->sureNotTypes);
+		$self->overwrite = $this->overwrite;
+		$self->specifyOnly = true;
+		$self->newConditionalExpressionHolders = $this->newConditionalExpressionHolders;
+		$self->rootExpr = $this->rootExpr;
+
+		return $self;
+	}
+
+	public function shouldSpecifyOnly(): bool
+	{
+		return $this->specifyOnly;
+	}
+
 	/**
 	 * @api
 	 */
 	public function setRootExpr(?Expr $rootExpr): self
 	{
 		$self = new self($this->sureTypes, $this->sureNotTypes);
 		$self->overwrite = $this->overwrite;
+		$self->specifyOnly = $this->specifyOnly;
 		$self->newConditionalExpressionHolders = $this->newConditionalExpressionHolders;
 		$self->rootExpr = $rootExpr;
 
@@ -77,6 +104,7 @@ public function setNewConditionalExpressionHolders(array $newConditionalExpressi
 	{
 		$self = new self($this->sureTypes, $this->sureNotTypes);
 		$self->overwrite = $this->overwrite;
+		$self->specifyOnly = $this->specifyOnly;
 		$self->newConditionalExpressionHolders = $newConditionalExpressionHolders;
 		$self->rootExpr = $this->rootExpr;
 
@@ -128,6 +156,7 @@ public function removeExpr(string $exprString): self
 
 		$self = new self($sureTypes, $sureNotTypes);
 		$self->overwrite = $this->overwrite;
+		$self->specifyOnly = $this->specifyOnly;
 		$self->newConditionalExpressionHolders = $this->newConditionalExpressionHolders;
 		$self->rootExpr = $this->rootExpr;
 
@@ -167,6 +196,9 @@ public function intersectWith(SpecifiedTypes $other): self
 		if ($this->overwrite && $other->overwrite) {
 			$result = $result->setAlwaysOverwriteTypes();
 		}
+		if ($this->specifyOnly || $other->specifyOnly) {
+			$result->specifyOnly = true;
+		}
 
 		return $result->setRootExpr($rootExpr);
 	}
@@ -204,6 +236,9 @@ public function unionWith(SpecifiedTypes $other): self
 		if ($this->overwrite || $other->overwrite) {
 			$result = $result->setAlwaysOverwriteTypes();
 		}
+		if ($this->specifyOnly || $other->specifyOnly) {
+			$result->specifyOnly = true;
+		}
 
 		$conditionalExpressionHolders = $this->newConditionalExpressionHolders;
 		foreach ($other->newConditionalExpressionHolders as $exprString => $holders) {
@@ -235,6 +270,7 @@ public function normalize(Scope $scope): self
 		if ($this->overwrite) {
 			$result = $result->setAlwaysOverwriteTypes();
 		}
+		$result->specifyOnly = $this->specifyOnly;
 
 		return $result->setRootExpr($this->rootExpr);
 	}

src/Analyser/TypeSpecifier.php

@@ -1856,7 +1856,10 @@ static function (Type $type, callable $traverse) use ($templateTypeMap, &$contai
 					$assertedType,
 					$assert->isNegated() ? TypeSpecifierContext::createFalse() : TypeSpecifierContext::createTrue(),
 					$scope,
-				)->setRootExpr($containsUnresolvedTemplate || $assert->isEquality() ? $call : null);
+				);
+				if ($containsUnresolvedTemplate || $assert->isEquality()) {
+					$newTypes = $newTypes->setSpecifyOnly();
+				}
 				$types = $types !== null ? $types->unionWith($newTypes) : $newTypes;
 
 				if (!$context->null() || !$assertedType instanceof ConstantBooleanType) {

src/Rules/Comparison/ImpossibleCheckTypeHelper.php

@@ -273,6 +273,20 @@
 			return null;
 		}
 
+		if ($specifiedTypes->shouldSpecifyOnly()) {
+			if ($scope->hasExpressionType($node)->yes()) {
+				$nodeType = $this->treatPhpDocTypesAsCertain ? $scope->getType($node) : $scope->getNativeType($node);
+				if ($nodeType->isTrue()->yes()) {
+					return true;
+				}
+				if ($nodeType->isFalse()->yes()) {
+					return false;
+				}
+			}
+
+			return null;
+		}
+
 		$sureTypes = $specifiedTypes->getSureTypes();
 		$sureNotTypes = $specifiedTypes->getSureNotTypes();
 

src/Type/Php/ArrayKeyExistsFunctionTypeSpecifyingExtension.php

@@ -3,10 +3,7 @@
 namespace PHPStan\Type\Php;
 
 use PhpParser\Node\Expr\ArrayDimFetch;
-use PhpParser\Node\Expr\BinaryOp\Identical;
-use PhpParser\Node\Expr\ConstFetch;
 use PhpParser\Node\Expr\FuncCall;
-use PhpParser\Node\Name;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
 use PHPStan\Analyser\TypeSpecifier;
@@ -115,7 +112,7 @@ public function specifyTypes(
 					$arrayType->getIterableValueType(),
 					$context,
 					$scope,
-				))->setRootExpr(new Identical($arrayDimFetch, new ConstFetch(new Name('__PHPSTAN_FAUX_CONSTANT'))));
+				))->setSpecifyOnly();
 			}
 
 			return new SpecifiedTypes();

src/Type/Php/PregMatchTypeSpecifyingExtension.php

@@ -83,7 +83,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 			$matchedType,
 			$context,
 			$scope,
-		)->setRootExpr($node);
+		)->setSpecifyOnly();
 		if ($overwrite) {
 			$types = $types->setAlwaysOverwriteTypes();
 		}

src/Type/Php/StrContainingTypeSpecifyingExtension.php

@@ -2,12 +2,7 @@
 
 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;
-use PhpParser\Node\Name;
-use PhpParser\Node\Scalar\String_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
 use PHPStan\Analyser\TypeSpecifier;
@@ -89,15 +84,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 					new IntersectionType($accessories),
 					$context,
 					$scope,
-				)->setRootExpr(new BooleanAnd(
-					new NotIdentical(
-						$args[$needleArg]->value,
-						new String_(''),
-					),
-					new FuncCall(new Name('FAUX_FUNCTION'), [
-						new Arg($args[$needleArg]->value),
-					]),
-				));
+				)->setSpecifyOnly();
 			}
 		}
 

tests/PHPStan/Analyser/nsrt/bug-14705.php

@@ -0,0 +1,149 @@
+<?php // lint >= 8.0
+
+namespace Bug14705;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+
+	/**
+	 * strpos with non-empty-string haystack should not report always-true.
+	 *
+	 * @param non-empty-string $haystack
+	 * @param non-empty-string $needle
+	 */
+	public function strposNonEmpty(string $haystack, string $needle): void
+	{
+		if (strpos($haystack, $needle) !== false) {
+			assertType('non-empty-string', $haystack);
+			assertType('non-empty-string', $needle);
+		}
+	}
+
+	/**
+	 * str_contains with non-empty-string haystack should not report always-true.
+	 *
+	 * @param non-empty-string $haystack
+	 */
+	public function strContainsNonEmpty(string $haystack, string $needle): void
+	{
+		if (str_contains($haystack, $needle)) {
+			assertType('non-empty-string', $haystack);
+			assertType('string', $needle);
+		}
+	}
+
+	/**
+	 * str_starts_with with non-empty-string haystack should not report always-true.
+	 *
+	 * @param non-empty-string $haystack
+	 */
+	public function strStartsWithNonEmpty(string $haystack, string $needle): void
+	{
+		if (str_starts_with($haystack, $needle)) {
+			assertType('non-empty-string', $haystack);
+			assertType('string', $needle);
+		}
+	}
+
+	/**
+	 * str_ends_with with non-empty-string haystack should not report always-true.
+	 *
+	 * @param non-empty-string $haystack
+	 */
+	public function strEndsWithNonEmpty(string $haystack, string $needle): void
+	{
+		if (str_ends_with($haystack, $needle)) {
+			assertType('non-empty-string', $haystack);
+			assertType('string', $needle);
+		}
+	}
+
+	/**
+	 * array_key_exists with non-constant key on a non-empty-array should not report always-true.
+	 *
+	 * @param non-empty-array<string, int> $array
+	 */
+	public function arrayKeyExistsNonEmpty(array $array, string $key): void
+	{
+		if (array_key_exists($key, $array)) {
+			assertType('non-empty-array<string, int>', $array);
+		}
+	}
+
+	/**
+	 * @phpstan-assert-if-true =non-empty-string $foo
+	 */
+	public function isValid(string $foo): bool
+	{
+		return $foo !== '';
+	}
+
+	public function equalityAssertDuplicate(string $task): void
+	{
+		if ($this->isValid($task)) {
+			assertType('non-empty-string', $task);
+			if ($this->isValid($task)) { // reported as always-true
+				assertType('non-empty-string', $task);
+			}
+		}
+	}
+
+	/**
+	 * @phpstan-assert =non-empty-string $foo
+	 */
+	public function assertValid(string $foo): void
+	{
+		if ($foo === '') {
+			throw new \Exception();
+		}
+	}
+
+	public function voidAssertDuplicate(string $task): void
+	{
+		$this->assertValid($task);
+		assertType('non-empty-string', $task);
+		$this->assertValid($task); // reported as always-true
+		assertType('non-empty-string', $task);
+	}
+
+	public function realpathElvis(string $fileName): void
+	{
+		$fileName = realpath($fileName) ?: $fileName;
+		assertType('string', $fileName);
+	}
+
+	/** @param list<string> $paths */
+	public function realpathElvisWithLoop(string $fileName, array $paths): void
+	{
+		$fileName = realpath($fileName) ?: $fileName;
+		assertType('string', $fileName);
+
+		foreach ($paths as $path) {
+			if (str_starts_with($fileName, $path)) {
+				assertType('string', $fileName);
+			}
+		}
+	}
+
+	/**
+	 * Duplicate array_key_exists after an early-continue narrows the negated
+	 * call to false, while the non-negated call stays bool.
+	 *
+	 * @param array<string,string|array<int,string>> $theInput
+	 * @phpstan-param array{'name':string,'owners':array<int,string>} $theInput
+	 * @param array<int,string> $theTags
+	 */
+	public function arrayKeyExistsDuplicateInLoop(array $theInput, array $theTags): void
+	{
+		foreach ($theTags as $tag) {
+			if (!array_key_exists($tag, $theInput)) {
+				continue;
+			}
+			assertType('false', !array_key_exists($tag, $theInput));
+			assertType('bool', array_key_exists($tag, $theInput)); // could be true
+		}
+	}
+
+}