Ask DependencyResolver about exported nodes only for the node classes that can have one

FileAnalyserCallback called resolveExportedNode() for every node the walk
reported. Now it asks once per node class whether a node of the class can be
exported or change the PHPDoc name scope, and skips the call for the rest.

resolveFileDependencies() now expands each class found in a file to its
ancestors once, and reads the referenced classes of each type object once.

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

Author: ondrejmirtes

src/Analyser/FileAnalyserCallback.php

@@ -59,6 +59,14 @@ final class FileAnalyserCallback
 	/** @var array<string, array<Collector<Node, mixed>>> */
 	private array $collectorsByNodeType = [];
 
+	/**
+	 * Whether a node of the class can be exported or change the PHPDoc name scope - most cannot, and
+	 * the walk does not ask DependencyResolver about them at all.
+	 *
+	 * @var array<string, bool>
+	 */
+	private array $exportableByNodeType = [];
+
 	/**
 	 * @param callable(Node $node, Scope $scope): void|null $outerNodeCallback
 	 * @param Node\Stmt[] $parserNodes
@@ -234,6 +242,10 @@ public function __invoke(Node $node, Scope $scope): void
 			$this->fileCollectedData[$scope->getFile()][get_class($collector)][] = $collectedData;
 		}
 
+		if (!($this->exportableByNodeType[$nodeType] ??= $this->dependencyResolver->canExportNode($node))) {
+			return;
+		}
+
 		try {
 			$exportedNode = $this->dependencyResolver->resolveExportedNode($node, $scope);
 			if ($exportedNode !== null) {

src/Dependency/DependencyResolver.php

@@ -15,6 +15,7 @@
 use function array_key_exists;
 use function array_values;
 use function get_class;
+use function is_string;
 use function spl_object_id;
 use function str_starts_with;
 
@@ -67,6 +68,14 @@ public function __construct(
 		$this->nameScopeTracker = new NamespaceUsesTracker();
 	}
 
+	/**
+	 * Whether resolveExportedNode() can do anything with a node of this class.
+	 */
+	public function canExportNode(Node $node): bool
+	{
+		return ($this->nodeProfiles[get_class($node)] ??= $this->resolveNodeProfile($node)) !== 0;
+	}
+
 	/**
 	 * What the node declares, so that the result cache notices when what a file declares changes.
 	 */
@@ -109,26 +118,34 @@ public function resolveFileDependencies(?Dependencies $dependencies, array $anal
 			return new ResolvedDependencies([], [], [], []);
 		}
 
-		/** @var array<string, array<int, ClassReflection|FunctionReflection|ConstantReflection>> $reflectionsByFile */
-		$reflectionsByFile = [];
+		// what each file depends on, in the order it was found: a class by its name, expanded to it and
+		// its ancestors once below, however many times it was found, and a function or a constant
+		/** @var array<string, array<string, string|FunctionReflection|ConstantReflection>> $foundByFile */
+		$foundByFile = [];
+		/** @var array<string, array<int, true>> $typesByFile */
+		$typesByFile = [];
 		/** @var array<string, array<int, ClassReflection>> $usedTraitsByFile */
 		$usedTraitsByFile = [];
 		/** @var array<string, string> $fileDependencies */
 		$fileDependencies = [];
-		$dependencies->walk(function (string $file, array $types, array $classNames, array $reflections, array $filePaths, array $usedTraits) use (&$reflectionsByFile, &$usedTraitsByFile, &$fileDependencies): void {
-			$fileReflections = $reflectionsByFile[$file] ?? [];
+		$dependencies->walk(static function (string $file, array $types, array $classNames, array $reflections, array $filePaths, array $usedTraits) use (&$foundByFile, &$typesByFile, &$usedTraitsByFile, &$fileDependencies): void {
 			foreach ($types as $type) {
+				$typeId = spl_object_id($type);
+				if (isset($typesByFile[$file][$typeId])) {
+					continue;
+				}
+
+				$typesByFile[$file][$typeId] = true;
 				foreach ($type->getReferencedClasses() as $className) {
-					$fileReflections += $this->getClassDependencies($className);
+					$foundByFile[$file]['c' . $className] ??= $className;
 				}
 			}
 			foreach ($classNames as $className) {
-				$fileReflections += $this->getClassDependencies($className);
+				$foundByFile[$file]['c' . $className] ??= $className;
 			}
 			foreach ($reflections as $reflection) {
-				$fileReflections[spl_object_id($reflection)] = $reflection;
+				$foundByFile[$file]['r' . spl_object_id($reflection)] = $reflection;
 			}
-			$reflectionsByFile[$file] = $fileReflections;
 			foreach ($filePaths as $filePath) {
 				$fileDependencies[$filePath] = $filePath;
 			}
@@ -137,6 +154,21 @@ public function resolveFileDependencies(?Dependencies $dependencies, array $anal
 			}
 		});
 
+		/** @var array<string, array<int, ClassReflection|FunctionReflection|ConstantReflection>> $reflectionsByFile */
+		$reflectionsByFile = [];
+		foreach ($foundByFile as $file => $found) {
+			$fileReflections = [];
+			foreach ($found as $item) {
+				if (is_string($item)) {
+					$fileReflections += $this->getClassDependencies($item);
+					continue;
+				}
+
+				$fileReflections[spl_object_id($item)] = $item;
+			}
+			$reflectionsByFile[$file] = $fileReflections;
+		}
+
 		$packages = [];
 		$classReflections = [];
 		foreach ($reflectionsByFile as $file => $reflections) {