Do not inherit @pure-unless-* tags into a method marked @phpstan-pure or @phpstan-impure

Author: zonuexe

src/PhpDoc/ResolvedPhpDocBlock.php

@@ -287,8 +287,15 @@ public function merge(ResolvedPhpDocBlock $parent, InheritedPhpDocParameterMappi
 		$result->paramTags = self::mergeParamTags($this->getParamTags(), $parent, $parameterMapping, $parentClass);
 		$result->paramOutTags = self::mergeParamOutTags($this->getParamOutTags(), $parent, $parameterMapping, $parentClass);
 		$result->paramsImmediatelyInvokedCallable = self::mergeParamsImmediatelyInvokedCallable($this->getParamsImmediatelyInvokedCallable(), $parent, $parameterMapping);
-		$result->paramsPureUnlessCallableIsImpure = self::mergeParamsPureUnlessCallableIsImpure($this->getParamsPureUnlessCallableIsImpure(), $parent, $parameterMapping);
-		$result->paramsPureUnlessParameterPassed = self::mergeParamsPureUnlessParameterPassed($this->getParamsPureUnlessParameterPassed(), $parent, $parameterMapping);
+		// @phpstan-pure / @phpstan-impure on the method itself replaces the parent's
+		// conditional purity, so the @pure-unless-* tags are inherited only without them.
+		if ($this->isPure() === null) {
+			$result->paramsPureUnlessCallableIsImpure = self::mergeParamsPureUnlessCallableIsImpure($this->getParamsPureUnlessCallableIsImpure(), $parent, $parameterMapping);
+			$result->paramsPureUnlessParameterPassed = self::mergeParamsPureUnlessParameterPassed($this->getParamsPureUnlessParameterPassed(), $parent, $parameterMapping);
+		} else {
+			$result->paramsPureUnlessCallableIsImpure = $this->getParamsPureUnlessCallableIsImpure();
+			$result->paramsPureUnlessParameterPassed = $this->getParamsPureUnlessParameterPassed();
+		}
 		$result->paramClosureThisTags = self::mergeParamClosureThisTags($this->getParamClosureThisTags(), $parent, $parameterMapping, $parentClass);
 		$result->returnTag = self::mergeReturnTags($this->getReturnTag(), $declaringClass, $parent, $parameterMapping, $parentClass);
 		$result->throwsTag = self::mergeThrowsTags($this->getThrowsTag(), $parent, $parameterMapping);

src/Rules/Pure/FunctionPurityCheck.php

@@ -154,14 +154,13 @@ public function check(
 			}
 
 			$errors = array_merge($errors, $this->reportImpurePoints($impurePoints, $pureUnlessCallableParamNames, $functionDescription));
-		} elseif (!$isPure->no() && ($pureUnlessCallableParamNames !== [] || $pureUnlessParameterPassedParamNames !== [])) {
+		} elseif ($pureUnlessCallableParamNames !== [] || $pureUnlessParameterPassedParamNames !== []) {
 			// A function declared @pure-unless-callable-is-impure is pure except
 			// for the flagged callables, so its body is checked for purity while
 			// the flagged callables' own invocations are exempt. The same holds for
 			// @pure-unless-parameter-passed: writing through the flagged by-ref
 			// parameter is not an impure point, so the rest of the body still has
-			// to be pure for the conditional verdict to hold. A method marked
-			// @phpstan-impure that inherits either tag makes no such promise.
+			// to be pure for the conditional verdict to hold.
 			$errors = array_merge($errors, $this->reportImpurePoints($impurePoints, $pureUnlessCallableParamNames, $functionDescription));
 		} elseif ($isPure->no()) {
 			if (

tests/PHPStan/Rules/Pure/PureMethodRuleTest.php

@@ -444,19 +444,27 @@ public function testPureUnlessImpureOverride(): void
 		$this->analyse([__DIR__ . '/data/pure-unless-impure-override.php'], [
 			[
 				'Method PureUnlessImpureOverride\ImpureReplacerWithoutSideEffects::replace() is marked as impure but does not have any side effects.',
-				57,
+				58,
 			],
 			[
 				'Method PureUnlessImpureOverride\ImpureReplacerWithoutSideEffects::map() is marked as impure but does not have any side effects.',
-				65,
+				66,
 			],
 			[
 				'Impure echo in pure method PureUnlessImpureOverride\InheritingReplacer::replace().',
-				77,
+				78,
 			],
 			[
 				'Impure echo in pure method PureUnlessImpureOverride\InheritingReplacer::map().',
-				85,
+				86,
+			],
+			[
+				'Method PureUnlessImpureOverride\PureReplacer::replace() is marked as pure but parameter $count is passed by reference.',
+				102,
+			],
+			[
+				'Possibly impure call to a callable in pure method PureUnlessImpureOverride\PureReplacer::map().',
+				115,
 			],
 		]);
 	}

tests/PHPStan/Rules/Pure/data/pure-unless-impure-override.php

@@ -23,8 +23,9 @@ final class ImpureReplacer implements Replacer
 {
 
 	/**
-	 * The method is marked impure, so its body is not checked for purity
-	 * although it inherits @pure-unless-parameter-passed.
+	 * @phpstan-impure on the method replaces the inherited
+	 * @pure-unless-parameter-passed, so the body is not checked for purity.
+	 * MethodSignatureRule reports the override instead.
 	 *
 	 * @phpstan-impure
 	 */
@@ -88,3 +89,30 @@ public function map(callable $cb, string $subject): string
 	}
 
 }
+
+final class PureReplacer implements Replacer
+{
+
+	/**
+	 * @phpstan-pure on the method replaces the inherited
+	 * @pure-unless-parameter-passed, so writing to $count is not exempt.
+	 *
+	 * @phpstan-pure
+	 */
+	public function replace(string $subject, int &$count = 0): string
+	{
+		return $subject;
+	}
+
+	/**
+	 * @phpstan-pure on the method replaces the inherited
+	 * @pure-unless-callable-is-impure, so invoking $cb is not exempt.
+	 *
+	 * @phpstan-pure
+	 */
+	public function map(callable $cb, string $subject): string
+	{
+		return $cb($subject);
+	}
+
+}