Rerun a rule on CollectedDataNode when what a class declares changed

A class reflection extension records with DeclarationDependencyTracker what a class
declares depends on. A rule on CollectedDataNode can read such a class, but it is not
known which classes it read. An extension also describes a class only once per process,
so a second rule that reads the class records nothing.

So a rule now gets the values of every class seen in the process. A changed value runs
the rule again. A value of a class that the rule did not read causes an extra run only.

Every rule now has the same values, so the finalizer asks for each current value once
per run, not once per rule.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: 2 people

.github/workflows/e2e-tests.yml

@@ -266,6 +266,12 @@ jobs:
               OUTPUT=$(../bashunit assert exit_code "1" "../../bin/phpstan analyse -vv --error-format raw")
               echo "$OUTPUT"
               ../bashunit assert contains 'Controller.php:20:View contact not found.' "$OUTPUT"
+              # And a method that a class reflection extension describes from a file that is not
+              # analysed, tracked through DeclarationDependencyTracker. No analysed file changes.
+              printf '' > more-views.txt
+              OUTPUT=$(../bashunit assert exit_code "1" "../../bin/phpstan analyse -vv --error-format raw")
+              echo "$OUTPUT"
+              ../bashunit assert contains 'Controller.php:25:View faq not found.' "$OUTPUT"
           - script: |
               cd e2e/bug-14514
               composer install

e2e/result-cache-collected-data-rules-tracking/extension/MoreViewsExtension.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheCollectedDataRulesTracking;
+
+use PHPStan\Analyser\DeclarationDependencyTracker;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\MethodsClassReflectionExtension;
+use PHPStan\Type\StringType;
+use function file;
+use function in_array;
+
+/**
+ * MoreViews has a method for each view listed in a file that is not analysed. A class reflection
+ * extension gets no Scope, so it tracks the file on the class.
+ */
+final class MoreViewsExtension implements MethodsClassReflectionExtension
+{
+
+	public function __construct(
+		private DeclarationDependencyTracker $declarationDependencyTracker,
+		private string $moreViewsFile,
+	)
+	{
+	}
+
+	public function hasMethod(ClassReflection $classReflection, string $methodName): bool
+	{
+		if ($classReflection->getName() !== MoreViews::class) {
+			return false;
+		}
+
+		$this->declarationDependencyTracker->trackFileDependency($classReflection, $this->moreViewsFile);
+
+		return in_array($methodName, file($this->moreViewsFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES), true);
+	}
+
+	public function getMethod(ClassReflection $classReflection, string $methodName): MethodReflection
+	{
+		return new ViewMethodReflection($classReflection, $methodName, new StringType());
+	}
+
+}

e2e/result-cache-collected-data-rules-tracking/extension/ViewMethodReflection.php

@@ -0,0 +1,90 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheCollectedDataRulesTracking;
+
+use PHPStan\Reflection\ClassMemberReflection;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\FunctionVariant;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\Type;
+
+final class ViewMethodReflection implements MethodReflection
+{
+
+	public function __construct(private ClassReflection $declaringClass, private string $name, private Type $returnType)
+	{
+	}
+
+	public function getDeclaringClass(): ClassReflection
+	{
+		return $this->declaringClass;
+	}
+
+	public function isStatic(): bool
+	{
+		return false;
+	}
+
+	public function isPrivate(): bool
+	{
+		return false;
+	}
+
+	public function isPublic(): bool
+	{
+		return true;
+	}
+
+	public function getDocComment(): ?string
+	{
+		return null;
+	}
+
+	public function getName(): string
+	{
+		return $this->name;
+	}
+
+	public function getPrototype(): ClassMemberReflection
+	{
+		return $this;
+	}
+
+	public function getVariants(): array
+	{
+		return [new FunctionVariant(TemplateTypeMap::createEmpty(), null, [], false, $this->returnType)];
+	}
+
+	public function isDeprecated(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
+	public function getDeprecatedDescription(): ?string
+	{
+		return null;
+	}
+
+	public function isFinal(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
+	public function isInternal(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
+	public function getThrowType(): ?Type
+	{
+		return null;
+	}
+
+	public function hasSideEffects(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
+}

e2e/result-cache-collected-data-rules-tracking/extension/ViewRule.php

@@ -17,7 +17,8 @@
 /**
  * Reports a view without a file in the views directory, unless the view is listed in a file of
  * ignored views or is a constant of ExtraViews. None of them is analysed, so the rule declares
- * all three.
+ * all three. A view can also be a method of MoreViews, which MoreViewsExtension describes and
+ * declares itself.
  *
  * @implements Rule<CollectedDataNode>
  */
@@ -48,10 +49,11 @@ public function processNode(Node $node, Scope $scope): array
 
 		$ignoredViews = file($this->ignoredViewsFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
 		$extraViews = $this->reflectionProvider->getClass(ExtraViews::class)->getNativeReflection()->getConstants();
+		$moreViews = $this->reflectionProvider->getClass(MoreViews::class);
 		$errors = [];
 		foreach ($node->get(ViewCollector::class) as $file => $views) {
 			foreach ($views as [$view, $line]) {
-				if (is_file($this->viewsDirectory . '/' . $view . '.txt') || in_array($view, $ignoredViews, true) || in_array($view, $extraViews, true)) {
+				if (is_file($this->viewsDirectory . '/' . $view . '.txt') || in_array($view, $ignoredViews, true) || in_array($view, $extraViews, true) || $moreViews->hasMethod($view)) {
 					continue;
 				}
 

e2e/result-cache-collected-data-rules-tracking/lib/MoreViews.php

@@ -0,0 +1,11 @@
+<?php declare(strict_types = 1);
+
+namespace ResultCacheCollectedDataRulesTracking;
+
+/**
+ * Has a method for each view in more-views.txt, from MoreViewsExtension.
+ */
+class MoreViews
+{
+
+}

e2e/result-cache-collected-data-rules-tracking/more-views.txt

@@ -0,0 +1 @@
+faq

e2e/result-cache-collected-data-rules-tracking/phpstan.neon

@@ -21,3 +21,9 @@ services:
 			ignoredViewsFile: %currentWorkingDirectory%/ignored-views.txt
 		tags:
 			- phpstan.rules.rule
+	-
+		class: ResultCacheCollectedDataRulesTracking\MoreViewsExtension
+		arguments:
+			moreViewsFile: %currentWorkingDirectory%/more-views.txt
+		tags:
+			- phpstan.broker.methodsClassReflectionExtension

e2e/result-cache-collected-data-rules-tracking/src/Controller.php

@@ -20,4 +20,9 @@ public function contact(): string
 		return view('contact');
 	}
 
+	public function faq(): string
+	{
+		return view('faq');
+	}
+
 }

src/Analyser/AnalyserResultFinalizer.php

@@ -105,13 +105,14 @@ public function finalize(
 		$collectedDataRuleResults = [];
 		$reusedRulesCount = 0;
 		$ruleCountsByClass = [];
+		$currentValues = [];
 		foreach ($this->ruleRegistry->getRules($nodeType) as $rule) {
 			$ruleClass = get_class($rule);
 			$ruleCountsByClass[$ruleClass] = ($ruleCountsByClass[$ruleClass] ?? 0) + 1;
 			$ruleKey = sprintf('%s#%d', $ruleClass, $ruleCountsByClass[$ruleClass]);
 
 			$previousResult = $this->reuseCollectedDataRuleErrors ? $previousCollectedDataRuleResults[$ruleKey] ?? null : null;
-			if ($previousResult !== null && $this->canReuse($previousResult, $onlyFiles, $hashCollector)) {
+			if ($previousResult !== null && $this->canReuse($previousResult, $onlyFiles, $hashCollector, $currentValues)) {
 				$collectedDataRuleResults[$ruleKey] = $previousResult;
 				$reusedRulesCount++;
 				$this->addRuleErrors($previousResult->getErrors(), $node, $scope, $tempCollectorErrors);
@@ -265,8 +266,9 @@ private function createRuleResult(CollectedDataNodeReads $reads, bool $onlyFiles
 
 	/**
 	 * @param Closure(string): string $hashCollector
+	 * @param array<string, string> $currentValues id => value, asked for once per run - every rule shares the values of the classes
 	 */
-	private function canReuse(CollectedDataRuleResult $previousResult, bool $onlyFiles, Closure $hashCollector): bool
+	private function canReuse(CollectedDataRuleResult $previousResult, bool $onlyFiles, Closure $hashCollector, array &$currentValues): bool
 	{
 		$previousOnlyFiles = $previousResult->getOnlyFiles();
 		if ($previousOnlyFiles !== null && $previousOnlyFiles !== $onlyFiles) {
@@ -286,7 +288,9 @@ private function canReuse(CollectedDataRuleResult $previousResult, bool $onlyFil
 				return false;
 			}
 
-			if ($extension->getValue($extension->keyFromResultCache($storedKey)) !== $value) {
+			$id = ValueDependencyCollector::getId($extensionClass, $storedKey);
+			$currentValues[$id] ??= $extension->getValue($extension->keyFromResultCache($storedKey));
+			if ($currentValues[$id] !== $value) {
 				return false;
 			}
 		}

src/Analyser/ValueDependencyCollector.php

@@ -49,6 +49,8 @@
  * and reused by every file analysed after it without asking the extension again, so these are kept
  * for the whole process too, by class, and every file depending on the class - or on a class
  * extending it or implementing it - gets them as its own dependencies when its analysis finishes.
+ * A rule for CollectedDataNode gets those of every class, because it is not known which classes
+ * it read.
  *
  * @phpstan-type ValueDependencies = array{
  *     values: array<string, array{string, string, string}>,
@@ -171,11 +173,23 @@ public function startCollectedDataRule(): void
 	}
 
 	/**
+	 * With what every class seen in this process declares depends on, see recordForClass(): the
+	 * rule may have read any of them, and an extension describes a class only once per process.
+	 *
 	 * @return array<string, array{string, string, string}> id => [extension class, key, value]
 	 */
 	public function getCollectedDataRuleValues(): array
 	{
-		return $this->collectedDataRuleValues ?? [];
+		if ($this->collectedDataRuleValues === null) {
+			return [];
+		}
+
+		$values = $this->collectedDataRuleValues;
+		foreach ($this->classDeclarations as $classValues) {
+			$values += $classValues;
+		}
+
+		return $values;
 	}
 
 	public function finishCollectedDataRule(): void