Replace FAUX function call workarounds

src/Analyser/MutatingScope.php

@@ -3265,6 +3265,12 @@ public function filterByTruthyValue(Expr $expr): self
 		}
 
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition($this, $expr, TypeSpecifierContext::createTruthy());
+		if ($specifiedTypes->shouldSpecifyOnly()) {
+			[$markerExpr, $markerValue] = $this->unwrapSpecifyOnlyMarker($expr, true);
+			$specifiedTypes = $specifiedTypes->unionWith(
+				$this->typeSpecifier->create($markerExpr, new ConstantBooleanType($markerValue), TypeSpecifierContext::createTrue(), $this),
+			);
+		}
 		$scope = $this->filterBySpecifiedTypes($specifiedTypes);
 		$this->truthyScopes[$exprString] = $scope;
 
@@ -3282,12 +3288,36 @@ public function filterByFalseyValue(Expr $expr): self
 		}
 
 		$specifiedTypes = $this->typeSpecifier->specifyTypesInCondition($this, $expr, TypeSpecifierContext::createFalsey());
+		if ($specifiedTypes->shouldSpecifyOnly()) {
+			[$markerExpr, $markerValue] = $this->unwrapSpecifyOnlyMarker($expr, false);
+			$specifiedTypes = $specifiedTypes->unionWith(
+				$this->typeSpecifier->create($markerExpr, new ConstantBooleanType($markerValue), TypeSpecifierContext::createTrue(), $this),
+			);
+		}
 		$scope = $this->filterBySpecifiedTypes($specifiedTypes);
 		$this->falseyScopes[$exprString] = $scope;
 
 		return $scope;
 	}
 
+	/**
+	 * Strips BooleanNot wrappers from a specifyOnly condition so the boolean
+	 * result marker is stored for the underlying call (e.g. `array_key_exists(...)`)
+	 * rather than for the negated form (`!array_key_exists(...)`). The negated form
+	 * is then derived from the inner value instead of being capped at bool.
+	 *
+	 * @return array{Expr, bool}
+	 */
+	private function unwrapSpecifyOnlyMarker(Expr $expr, bool $value): array
+	{
+		while ($expr instanceof Expr\BooleanNot) {
+			$expr = $expr->expr;
+			$value = !$value;
+		}
+
+		return [$expr, $value];
+	}
+
 	/**
 	 * @return static
 	 */

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,31 @@ 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()) {
+				// This is the expression-statement counterpart of the specifyOnly handling
+				// in MutatingScope::filterByTruthyValue(). A void assertion method used as a
+				// statement (e.g. `$this->assertValid($x);` with `@phpstan-assert =non-empty-string $x`)
+				// only narrows types as a side effect and never determines a check outcome, so
+				// ImpossibleCheckTypeHelper would otherwise have nothing to detect a duplicate
+				// call against. Store ConstantBooleanType(true) for the call expression so a
+				// second identical call is reported as always-true. Unlike filterByTruthyValue,
+				// we overwrite directly instead of going through TypeSpecifier::create(): void
+				// calls are not used for their return value, so the purity check there would
+				// drop the marker for the impure calls that need it most, and intersecting
+				// `true` with the void return type would produce *NEVER*.
+				$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,53 @@ 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.
+	 *
+	 * Duplicate detection: filterByTruthyValue stores the call's boolean
+	 * result via TypeSpecifier::create(), which respects purity checks.
+	 * Pure/possibly-impure calls get duplicate detection; impure calls
+	 * (hasSideEffects=yes) do not, to avoid overwriting the expression's
+	 * real return type in scope. Void assertion methods used as statements
+	 * get duplicate detection via NodeScopeResolver's expression statement
+	 * path, which bypasses purity checks since void calls are not used
+	 * for their return value.
+	 *
+	 * @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 +113,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 +165,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 +205,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 +245,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 +279,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/Rules/Methods/MethodCallWithPossiblyRenamedNamedArgumentRule.php

@@ -51,10 +51,6 @@ public function processNode(Node $node, NodeCallbackInvoker&Scope&CollectedDataE
 					continue;
 				}
 
-				if (!array_key_exists($prototypeParameterName, $prototypeMethodCalls)) {
-					continue;
-				}
-
 				$callsWithParameter = $prototypeMethodCalls[$prototypeParameterName];
 				foreach ($callsWithParameter as [$file, $line]) {
 					$errors[] = RuleErrorBuilder::message(sprintf(

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();
 			}
 		}