Treat declarations with a non-void @throws as not effect-free in the CallTo*StatementWithoutImpurePointsRule family

- `ConstructorWithoutImpurePointsCollector`, `MethodWithoutImpurePointsCollector` and `FunctionWithoutImpurePointsCollector` now bail out (return `null`) when the declaration has a non-null, non-`void` `getThrowType()`.
- This fixes false positives where a constructor/function/method declares `@throws` but its only `throw` lives in a branch PHPStan proves dead, so the throw point is discarded and the declaration was wrongly considered pure.
- The transitive chain was already covered: a live call to a `@throws` declaration produces an explicit throw point at the call site, which the resolver already treats as impure.
- Added `testThrows` regression tests and data files for all four rules (constructor, function, method, static method), each pairing a `@throws` declaration (not reported) with a no-`@throws` sibling (still reported).

Author: phpstan-bot

src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php

@@ -48,6 +48,11 @@ public function processNode(Node $node, Scope $scope)
 			return null;
 		}
 
+		$throwType = $method->getThrowType();
+		if ($throwType !== null && !$throwType->isVoid()->yes()) {
+			return null;
+		}
+
 		$dependencies = $this->purityResolver->resolveDependencies(
 			$node->getImpurePoints(),
 			$node->getStatementResult()->getThrowPoints(),

src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php

@@ -47,6 +47,11 @@ public function processNode(Node $node, Scope $scope)
 			return null;
 		}
 
+		$throwType = $function->getThrowType();
+		if ($throwType !== null && !$throwType->isVoid()->yes()) {
+			return null;
+		}
+
 		$dependencies = $this->purityResolver->resolveDependencies(
 			$node->getImpurePoints(),
 			$node->getStatementResult()->getThrowPoints(),

src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php

@@ -51,6 +51,11 @@ public function processNode(Node $node, Scope $scope)
 			return null;
 		}
 
+		$throwType = $method->getThrowType();
+		if ($throwType !== null && !$throwType->isVoid()->yes()) {
+			return null;
+		}
+
 		$dependencies = $this->purityResolver->resolveDependencies(
 			$node->getImpurePoints(),
 			$node->getStatementResult()->getThrowPoints(),

tests/PHPStan/Rules/DeadCode/CallToConstructorStatementWithoutImpurePointsRuleTest.php

@@ -36,6 +36,16 @@ public function testTransitive(): void
 		]);
 	}
 
+	public function testThrows(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-constructor-without-impure-points-throws.php'], [
+			[
+				'Call to new CallToConstructorWithoutImpurePointsThrows\NoThrows() on a separate line has no effect.',
+				39,
+			],
+		]);
+	}
+
 	protected function getCollectors(): array
 	{
 		$purityResolver = new PossiblyPureCallTransitivePurityResolver(self::createReflectionProvider());

tests/PHPStan/Rules/DeadCode/CallToFunctionStatementWithoutImpurePointsRuleTest.php

@@ -45,6 +45,16 @@ public function testTransitive(): void
 		]);
 	}
 
+	public function testThrows(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-function-without-impure-points-throws.php'], [
+			[
+				'Call to function CallToFunctionWithoutImpurePointsThrows\noThrowsFunc() on a separate line has no effect.',
+				29,
+			],
+		]);
+	}
+
 	#[RequiresPhp('>= 8.5.0')]
 	public function testPipeOperator(): void
 	{

tests/PHPStan/Rules/DeadCode/CallToMethodStatementWithoutImpurePointsRuleTest.php

@@ -100,6 +100,16 @@ public function testBug11011(): void
 		]);
 	}
 
+	public function testThrows(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-method-without-impure-points-throws.php'], [
+			[
+				'Call to method CallToMethodWithoutImpurePointsThrows\Foo::noThrowsMethod() on a separate line has no effect.',
+				34,
+			],
+		]);
+	}
+
 	#[RequiresPhp('>= 8.0.0')]
 	public function testBug12379(): void
 	{

tests/PHPStan/Rules/DeadCode/CallToStaticMethodStatementWithoutImpurePointsRuleTest.php

@@ -71,6 +71,16 @@ public function testRule(): void
 		]);
 	}
 
+	public function testThrows(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-static-method-without-impure-points-throws.php'], [
+			[
+				'Call to CallToStaticMethodWithoutImpurePointsThrows\Foo::noThrowsStatic() on a separate line has no effect.',
+				34,
+			],
+		]);
+	}
+
 	#[RequiresPhp('>= 8.5.0')]
 	public function testPipeOperator(): void
 	{

tests/PHPStan/Rules/DeadCode/data/call-to-constructor-without-impure-points-throws.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace CallToConstructorWithoutImpurePointsThrows;
+
+class InvalidFileInfo extends \Exception
+{
+
+}
+
+class FileIteratorSourceLocator
+{
+
+	/**
+	 * @param array<int> $ints
+	 * @throws InvalidFileInfo
+	 */
+	public function __construct(array $ints)
+	{
+		foreach ($ints as $int) {
+			if (!is_int($int)) {
+				throw new InvalidFileInfo();
+			}
+		}
+	}
+
+}
+
+class NoThrows
+{
+
+	public function __construct()
+	{
+	}
+
+}
+
+function (): void {
+	new FileIteratorSourceLocator([1, 2, 3]);
+	new NoThrows();
+};

tests/PHPStan/Rules/DeadCode/data/call-to-function-without-impure-points-throws.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace CallToFunctionWithoutImpurePointsThrows;
+
+class InvalidValue extends \Exception
+{
+
+}
+
+/**
+ * @param array<int> $ints
+ * @throws InvalidValue
+ */
+function throwingFunc(array $ints)
+{
+	foreach ($ints as $int) {
+		if (!is_int($int)) {
+			throw new InvalidValue();
+		}
+	}
+}
+
+function noThrowsFunc()
+{
+}
+
+function (): void {
+	throwingFunc([1, 2, 3]);
+	noThrowsFunc();
+};

tests/PHPStan/Rules/DeadCode/data/call-to-method-without-impure-points-throws.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace CallToMethodWithoutImpurePointsThrows;
+
+class InvalidValue extends \Exception
+{
+
+}
+
+final class Foo
+{
+
+	/**
+	 * @param array<int> $ints
+	 * @throws InvalidValue
+	 */
+	public function throwingMethod(array $ints)
+	{
+		foreach ($ints as $int) {
+			if (!is_int($int)) {
+				throw new InvalidValue();
+			}
+		}
+	}
+
+	public function noThrowsMethod()
+	{
+	}
+
+}
+
+function (Foo $foo): void {
+	$foo->throwingMethod([1, 2, 3]);
+	$foo->noThrowsMethod();
+};