Dynamic throw type extensions and collectors can track dependencies

Their scope is Scope&DependencyTracker, the same as for dynamic return type
extensions and rules. A collector reading something PHPStan does not know
about can track it, and the file is analysed again and its data collected
again when it changes.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GdwtgiEHwkF5BTz73jgHQQ

Author: ondrejmirtes

.github/workflows/e2e-tests.yml

@@ -452,6 +452,8 @@ jobs:
               ../bashunit -a contains "UsesLocaleToo.php:10:Function ResultCacheE2EValueDependency\usesLocaleToo() should return 'none' but returns 'cs'." "$OUTPUT"
               ../bashunit -a contains 'Holder.php:17:Method ResultCacheE2EValueDependency\Holder::isDebug() should return int but returns string.' "$OUTPUT"
               ../bashunit -a contains 'UsesHolder.php:9:Function ResultCacheE2EValueDependency\usesHolder() should return int but returns string.' "$OUTPUT"
+              ../bashunit -a contains 'UsesMayThrow.php:9:Dead catch - RuntimeException is never thrown in the try block.' "$OUTPUT"
+              ../bashunit -a contains 'UsesRegion.php:7:Region eu is used.' "$OUTPUT"
               ../bashunit -a not_contains 'UsesMailer.php' "$OUTPUT"
               # The extensions read container.json, which the result cache knows nothing about. A rule and a
               # dynamic return type extension both declare the service they ask about - it is recorded once.
@@ -507,6 +509,23 @@ jobs:
               echo "$OUTPUT"
               ../bashunit -a contains 'UsesLogger.php:7:Call to an undefined method ResultCacheE2EValueDependency\Mailer::log().' "$OUTPUT"
               ../bashunit -a contains 'LoggerTrait.php (in context of class ResultCacheE2EValueDependency\UsesLoggerTrait):10:Call to an undefined method ResultCacheE2EValueDependency\Mailer::log().' "$OUTPUT"
+              # A dynamic throw type extension tracks the values it reads too.
+              php -r '$c = json_decode(file_get_contents("container.json"), true); $c["parameters"]["throwing"] = "yes"; file_put_contents("container.json", json_encode($c, JSON_PRETTY_PRINT));'
+              INFO=$(../../bin/phpstan result-cache-info --json)
+              echo "$INFO"
+              ../bashunit -a equals '1' "$(echo "$INFO" | jq --raw-output '.filesToAnalyseCount')"
+              OUTPUT=$(../bashunit -a exit_code "1" "../../bin/phpstan analyse -vv --error-format raw")
+              echo "$OUTPUT"
+              ../bashunit -a not_contains 'Dead catch' "$OUTPUT"
+              # So does a collector: the data it collected is collected again in the analysis of the file.
+              php -r '$c = json_decode(file_get_contents("container.json"), true); $c["parameters"]["region"] = "us"; file_put_contents("container.json", json_encode($c, JSON_PRETTY_PRINT));'
+              INFO=$(../../bin/phpstan result-cache-info --json)
+              echo "$INFO"
+              ../bashunit -a equals '1' "$(echo "$INFO" | jq --raw-output '.filesToAnalyseCount')"
+              OUTPUT=$(../bashunit -a exit_code "1" "../../bin/phpstan analyse -vv --error-format raw")
+              echo "$OUTPUT"
+              ../bashunit -a contains 'UsesRegion.php:7:Region us is used.' "$OUTPUT"
+              ../bashunit -a not_contains 'Region eu is used.' "$OUTPUT"
           - script: |
               cd e2e/result-cache-file-dependency
               composer install

e2e/result-cache-value-dependency/container.json

@@ -6,6 +6,8 @@
 	"parameters": {
 		"locale": "cs",
 		"timezone": "Europe/Prague",
-		"debug": "yes"
+		"debug": "yes",
+		"throwing": "no",
+		"region": "eu"
 	}
 }

e2e/result-cache-value-dependency/extension/MayThrowThrowTypeExtension.php

@@ -0,0 +1,34 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheE2EValueDependency;
+
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\DependencyTracker;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\DynamicFunctionThrowTypeExtension;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+/**
+ * mayThrow() throws when the "throwing" parameter says so.
+ */
+final class MayThrowThrowTypeExtension implements DynamicFunctionThrowTypeExtension
+{
+
+	public function isFunctionSupported(FunctionReflection $functionReflection): bool
+	{
+		return $functionReflection->getName() === 'ResultCacheE2EValueDependency\mayThrow';
+	}
+
+	/**
+	 * @param Scope&DependencyTracker $scope
+	 */
+	public function getThrowTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, Scope $scope): ?Type
+	{
+		$scope->trackValueDependency(ParameterValueExtension::class, 'throwing');
+
+		return Container::getParameter('throwing') === 'yes' ? new ObjectType(\RuntimeException::class) : null;
+	}
+
+}

e2e/result-cache-value-dependency/extension/RegionCollector.php

@@ -0,0 +1,39 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheE2EValueDependency;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\DependencyTracker;
+use PHPStan\Analyser\Scope;
+use PHPStan\Collectors\Collector;
+
+/**
+ * Collects the "region" parameter at the calls to region().
+ *
+ * @implements Collector<FuncCall, string>
+ */
+final class RegionCollector implements Collector
+{
+
+	public function getNodeType(): string
+	{
+		return FuncCall::class;
+	}
+
+	/**
+	 * @param Scope&DependencyTracker $scope
+	 */
+	public function processNode(Node $node, Scope $scope)
+	{
+		if (!$node->name instanceof Name || $node->name->getLast() !== 'region') {
+			return null;
+		}
+
+		$scope->trackValueDependency(ParameterValueExtension::class, 'region');
+
+		return Container::getParameter('region') ?? 'missing';
+	}
+
+}

e2e/result-cache-value-dependency/extension/RegionRule.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheE2EValueDependency;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\CollectedDataNode;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * Reports what RegionCollector collected.
+ *
+ * @implements Rule<CollectedDataNode>
+ */
+final class RegionRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return CollectedDataNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$errors = [];
+		foreach ($node->get(RegionCollector::class) as $file => $regions) {
+			foreach ($regions as $region) {
+				$errors[] = RuleErrorBuilder::message(sprintf('Region %s is used.', $region))->identifier('resultCacheE2E.region')->file($file)->line(7)->build();
+			}
+		}
+
+		return $errors;
+	}
+
+}

e2e/result-cache-value-dependency/phpstan.neon

@@ -26,3 +26,15 @@ services:
 		class: ResultCacheE2EValueDependency\ParameterReturnTypeExtension
 		tags:
 			- phpstan.broker.dynamicFunctionReturnTypeExtension
+	-
+		class: ResultCacheE2EValueDependency\MayThrowThrowTypeExtension
+		tags:
+			- phpstan.dynamicFunctionThrowTypeExtension
+	-
+		class: ResultCacheE2EValueDependency\RegionCollector
+		tags:
+			- phpstan.collector
+	-
+		class: ResultCacheE2EValueDependency\RegionRule
+		tags:
+			- phpstan.rules.rule

e2e/result-cache-value-dependency/src/UsesMayThrow.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace ResultCacheE2EValueDependency;
+
+function usesMayThrow(): void
+{
+	try {
+		mayThrow();
+	} catch (\RuntimeException $e) {
+	}
+}

e2e/result-cache-value-dependency/src/UsesRegion.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace ResultCacheE2EValueDependency;
+
+function usesRegion(): string
+{
+	return region();
+}

e2e/result-cache-value-dependency/src/functions.php

@@ -14,3 +14,15 @@ function parameter(string $name)
 {
 	return $name === '' ? 0 : '';
 }
+
+/**
+ * @throws void
+ */
+function mayThrow(): void
+{
+}
+
+function region(): string
+{
+	return '';
+}

src/Analyser/DependencyTracker.php

@@ -5,9 +5,9 @@
 use PHPStan\Analyser\ResultCache\ResultCacheValueExtension;
 
 /**
- * The interface DependencyTracker can be typehinted in 2nd parameter of Rule::processNode(),
- * and in the Scope parameter of dynamic return type extensions, expression type resolver
- * extensions and parameter out type extensions:
+ * The interface DependencyTracker can be typehinted in 2nd parameter of Rule::processNode() and
+ * Collector::processNode(), and in the Scope parameter of dynamic return type extensions, dynamic
+ * throw type extensions, expression type resolver extensions and parameter out type extensions:
  *
  * ```php
  * /**