Honor @pure-unless-parameter-passed on constructor calls, unpacked and named arguments

NewHandler now applies the parameter-passed verdict to 'new' the same way the sibling callable verdict is applied (constructors return void, so createFromVariant cannot be reused). The verdict also treats argument unpacking conservatively (an unpacked argument might cover the flagged by-ref parameter, so the call stays possibly impure) and respects the flag's own TrinaryLogic certainty from union-variant composition (an uncertain flag downgrades a passed argument to Maybe instead of No).

Author: zonuexe

src/Analyser/ExprHandler/NewHandler.php

@@ -266,6 +266,17 @@ private function processConstructorReflection(string $className, New_ $expr, Mut
 				if ($verdict !== null && $verdict->no()) {
 					$certain = true;
 				}
+
+				if (!$certain) {
+					$passedVerdict = SimpleImpurePoint::resolvePureUnlessParameterPassedVerdict($parametersAcceptor, $expr->getArgs());
+					if ($passedVerdict !== null && $passedVerdict->yes()) {
+						return [$constructorReflection, $classReflection, $parametersAcceptor, $impurePoints];
+					}
+					if ($passedVerdict !== null && $passedVerdict->no()) {
+						$certain = true;
+					}
+				}
+
 				$impurePoints[] = new ImpurePoint(
 					$scope,
 					$expr,

src/Reflection/Callables/SimpleImpurePoint.php

@@ -237,8 +237,14 @@ public static function resolvePureUnlessParameterPassedVerdict(ParametersAccepto
 			$verdict ??= TrinaryLogic::createYes();
 
 			$matchedArg = null;
+			$hasUnpackedArg = false;
 			$hasNamedParameter = false;
 			foreach ($args as $i => $arg) {
+				if ($arg->unpack) {
+					$hasUnpackedArg = true;
+					continue;
+				}
+
 				if ($arg->name !== null) {
 					$hasNamedParameter = true;
 					if ($arg->name->name === $parameter->getName()) {
@@ -256,10 +262,24 @@ public static function resolvePureUnlessParameterPassedVerdict(ParametersAccepto
 			}
 
 			if ($matchedArg === null) {
+				if ($hasUnpackedArg) {
+					// An unpacked argument list (...$args) might supply the flagged
+					// by-ref parameter, so we cannot be sure the call stays pure.
+					$verdict = $verdict->and(TrinaryLogic::createMaybe());
+				}
+
+				continue;
+			}
+
+			if ($parameter->isPureUnlessParameterPassedParameter()->yes()) {
+				$verdict = $verdict->and(TrinaryLogic::createNo());
 				continue;
 			}
 
-			$verdict = $verdict->and(TrinaryLogic::createNo());
+			// The flag itself is uncertain (e.g. only one variant of a union type
+			// declares @pure-unless-parameter-passed), so passing an argument here
+			// only makes the call possibly impure, not certainly impure.
+			$verdict = $verdict->and(TrinaryLogic::createMaybe());
 		}
 
 		return $verdict;

tests/PHPStan/Rules/Pure/PureFunctionRuleTest.php

@@ -389,6 +389,22 @@ public function testPureUnlessParameterPassed(): void
 				'Possibly impure call to function PureUnlessParameterPassedFunction\myReplacePhpstanAlias() in pure function PureUnlessParameterPassedFunction\purePassingByRefAlias().',
 				62,
 			],
+			[
+				'Possibly impure call to function PureUnlessParameterPassedFunction\myReplace() in pure function PureUnlessParameterPassedFunction\pureUnpackingArgs().',
+				72,
+			],
+			[
+				'Possibly impure call to function PureUnlessParameterPassedFunction\myReplace() in pure function PureUnlessParameterPassedFunction\pureNamedArgForFlaggedParameter().',
+				91,
+			],
+			[
+				'Impure instantiation of class PureUnlessParameterPassedFunction\MyReplacerConstructor in pure function PureUnlessParameterPassedFunction\pureConstructorPassingByRef().',
+				127,
+			],
+			[
+				'Possibly impure call to method PureUnlessParameterPassedFunction\PureUnlessParameterPassedA::m() in pure function PureUnlessParameterPassedFunction\pureUnionMethodPassingCount().',
+				167,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Pure/data/pure-unless-parameter-passed.php

@@ -1,4 +1,4 @@
-<?php declare(strict_types = 1);
+<?php // lint >= 8.0
 
 namespace PureUnlessParameterPassedFunction;
 
@@ -61,3 +61,108 @@ function purePassingByRefAlias(string $s): string
 
 	return myReplacePhpstanAlias($s, $count);
 }
+
+/**
+ * @phpstan-pure
+ */
+function pureUnpackingArgs(string $s): string
+{
+	$args = [$s];
+	// An unpacked argument list might supply $count, so this stays possibly impure.
+	return myReplace(...$args);
+}
+
+/**
+ * @phpstan-pure
+ */
+function pureNamedArgForOtherParameter(string $s): string
+{
+	// The named argument targets $subject, not the flagged $count, so this stays pure.
+	return myReplace(subject: $s);
+}
+
+/**
+ * @phpstan-pure
+ */
+function pureNamedArgForFlaggedParameter(string $s): string
+{
+	$count = 0;
+	// The named argument explicitly targets the flagged $count parameter.
+	return myReplace(subject: $s, count: $count);
+}
+
+class MyReplacerConstructor
+{
+
+	public string $s;
+
+	/**
+	 * @param-out int $count
+	 * @pure-unless-parameter-passed $count
+	 */
+	public function __construct(string $s, int &$count = 0)
+	{
+		$this->s = $s;
+		$count = 1;
+	}
+
+}
+
+/**
+ * @phpstan-pure
+ */
+function pureConstructorNotPassingByRef(string $s): MyReplacerConstructor
+{
+	// $count is omitted, so instantiation stays pure.
+	return new MyReplacerConstructor($s);
+}
+
+/**
+ * @phpstan-pure
+ */
+function pureConstructorPassingByRef(string $s): MyReplacerConstructor
+{
+	$count = 0;
+	// $count is passed, so instantiation is impure (the flag is certain).
+	return new MyReplacerConstructor($s, $count);
+}
+
+interface PureUnlessParameterPassedA
+{
+
+	/**
+	 * @param-out int $count
+	 * @pure-unless-parameter-passed $count
+	 */
+	public function m(string $s, int &$count = 0): string;
+
+}
+
+interface PureUnlessParameterPassedB
+{
+
+	public function m(string $s, int &$count = 0): string;
+
+}
+
+/**
+ * @param PureUnlessParameterPassedA|PureUnlessParameterPassedB $obj
+ * @phpstan-pure
+ */
+function pureUnionMethodOmittingCount($obj, string $s): string
+{
+	// The flag is Yes in A and absent (No) in B, so combineAcceptors() merges it to Maybe.
+	// $count is omitted here, so the call stays pure regardless of the flag's certainty.
+	return $obj->m($s);
+}
+
+/**
+ * @param PureUnlessParameterPassedA|PureUnlessParameterPassedB $obj
+ * @phpstan-pure
+ */
+function pureUnionMethodPassingCount($obj, string $s): string
+{
+	$count = 0;
+	// $count is passed against the Maybe-flagged parameter, so this is possibly impure.
+	return $obj->m($s, $count);
+}