Allow custom rules to emit collector data for CollectedDataNode

src/Analyser/CollectedDataEmitter.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PhpParser\Node;
+use PHPStan\Collectors\Collector;
+
+/**
+ * The interface CollectedDataEmitter can be typehinted in 2nd parameter of Rule::processNode():
+ *
+ * ```php
+ * public function processNode(Node $node, Scope&CollectedDataEmitter $scope): array
+ * ```
+ *
+ * It allows rules to emit collected data directly, without having to write
+ * a separate complex Collector class. The emitted data is aggregated the same way
+ * as data from Collectors and can be consumed by rules registered
+ * for CollectedDataNode.
+ *
+ * The actual MyCollector class in the example has to exist, to verify
+ * the data type statically, and to identify the collected data.
+ *
+ * The referenced MyCollector class should NOT be registered
+ * as a collector, unless you also want it to collect data on its own.
+ *
+ * ```php
+ * $scope->emitCollectedData(MyCollector::class, ['some', 'data']);
+ * ```
+ *
+ * @api
+ */
+interface CollectedDataEmitter
+{
+
+	/**
+	 * @template TCollector of Collector<Node, mixed>
+	 * @param class-string<TCollector> $collectorType
+	 * @param template-type<TCollector, Collector, 'TValue'> $data
+	 */
+	public function emitCollectedData(string $collectorType, mixed $data): void;
+
+}

src/Analyser/FileAnalyserCallback.php

@@ -11,6 +11,7 @@
 use PHPStan\Collectors\Registry as CollectorRegistry;
 use PHPStan\Dependency\DependencyResolver;
 use PHPStan\Dependency\RootExportedNode;
+use PHPStan\Node\EmitCollectedDataNode;
 use PHPStan\Node\InClassNode;
 use PHPStan\Node\InTraitNode;
 use PHPStan\Parser\Parser;
@@ -77,9 +78,14 @@ public function __construct(
 
 	public function __invoke(Node $node, Scope $scope): void
 	{
+		if ($node instanceof EmitCollectedDataNode) {
+			$this->fileCollectedData[$scope->getFile()][$node->getCollectorType()][] = $node->getData();
+			return;
+		}
+
 		$parserNodes = $this->parserNodes;
 
-		/** @var Scope&NodeCallbackInvoker $scope */
+		/** @var Scope&NodeCallbackInvoker&CollectedDataEmitter $scope */
 		if ($node instanceof Node\Stmt\Trait_) {
 			foreach (array_keys($this->linesToIgnore[$this->file] ?? []) as $lineToIgnore) {
 				if ($lineToIgnore < $node->getStartLine() || $lineToIgnore > $node->getEndLine()) {

src/Analyser/MutatingScope.php

@@ -23,7 +23,9 @@
 use PhpParser\Node\Stmt\Function_;
 use PhpParser\NodeFinder;
 use PHPStan\Analyser\Traverser\TransformStaticTypeTraverser;
+use PHPStan\Collectors\Collector;
 use PHPStan\DependencyInjection\Container;
+use PHPStan\Node\EmitCollectedDataNode;
 use PHPStan\Node\Expr\AlwaysRememberedExpr;
 use PHPStan\Node\Expr\GetIterableKeyTypeExpr;
 use PHPStan\Node\Expr\IntertwinedVariableByReferenceWithExpr;
@@ -133,7 +135,7 @@
 use const PHP_INT_MIN;
 use const PHP_VERSION_ID;
 
-class MutatingScope implements Scope, NodeCallbackInvoker
+class MutatingScope implements Scope, NodeCallbackInvoker, CollectedDataEmitter
 {
 
 	public const KEEP_VOID_ATTRIBUTE_NAME = 'keepVoid';
@@ -4624,4 +4626,20 @@ public function invokeNodeCallback(Node $node): void
 		$nodeCallback($node, $this);
 	}
 
+	/**
+	 * @template TNodeType of Node
+	 * @template TValue
+	 * @param class-string<Collector<TNodeType, TValue>> $collectorType
+	 * @param TValue $data
+	 */
+	public function emitCollectedData(string $collectorType, mixed $data): void
+	{
+		$nodeCallback = $this->nodeCallback;
+		if ($nodeCallback === null) {
+			throw new ShouldNotHappenException('Node callback is not present in this scope');
+		}
+
+		$nodeCallback(new EmitCollectedDataNode($collectorType, $data), $this);
+	}
+
 }

src/Node/EmitCollectedDataNode.php

@@ -0,0 +1,60 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Node;
+
+use Override;
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+use PHPStan\Collectors\Collector;
+
+/**
+ * @template TNodeType of Node
+ * @template TValue
+ */
+final class EmitCollectedDataNode extends NodeAbstract implements VirtualNode
+{
+
+	/**
+	 * @param class-string<Collector<TNodeType, TValue>> $collectorType
+	 * @param TValue $data
+	 */
+	public function __construct(
+		private string $collectorType,
+		private mixed $data,
+	)
+	{
+		parent::__construct([]);
+	}
+
+	/**
+	 * @return class-string<Collector<TNodeType, TValue>>
+	 */
+	public function getCollectorType(): string
+	{
+		return $this->collectorType;
+	}
+
+	/**
+	 * @return TValue
+	 */
+	public function getData(): mixed
+	{
+		return $this->data;
+	}
+
+	#[Override]
+	public function getType(): string
+	{
+		return 'PHPStan_Node_EmitCollectedDataNode';
+	}
+
+	/**
+	 * @return list<string>
+	 */
+	#[Override]
+	public function getSubNodeNames(): array
+	{
+		return [];
+	}
+
+}

src/Rules/Methods/OverridingMethodRule.php

@@ -4,6 +4,7 @@
 
 use PhpParser\Node;
 use PhpParser\Node\Attribute;
+use PHPStan\Analyser\CollectedDataEmitter;
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredParameter;
@@ -49,7 +50,7 @@ public function getNodeType(): string
 		return InClassMethodNode::class;
 	}
 
-	public function processNode(Node $node, Scope&NodeCallbackInvoker $scope): array
+	public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataEmitter $scope): array
 	{
 		$method = $node->getMethodReflection();
 		$prototypeData = $this->methodPrototypeFinder->findPrototype($node->getClassReflection(), $method->getName());
@@ -329,7 +330,7 @@ private function filterOverrideAttribute(array $attrGroups): array
 	private function addErrors(
 		array $errors,
 		InClassMethodNode $classMethod,
-		Scope&NodeCallbackInvoker $scope,
+		Scope&NodeCallbackInvoker&CollectedDataEmitter $scope,
 	): array
 	{
 		if (count($errors) > 0) {

src/Rules/Playground/PromoteParameterRule.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Rules\Playground;
 
 use PhpParser\Node;
+use PHPStan\Analyser\CollectedDataEmitter;
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\Container;
@@ -88,7 +89,7 @@ private function getOriginalRule(): ?Rule
 		return $this->originalRule = $originalRule;
 	}
 
-	public function processNode(Node $node, Scope&NodeCallbackInvoker $scope): array
+	public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataEmitter $scope): array
 	{
 		if ($this->parameterValue) {
 			return [];

src/Rules/Rule.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Rules;
 
 use PhpParser\Node;
+use PHPStan\Analyser\CollectedDataEmitter;
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 
@@ -35,6 +36,6 @@ public function getNodeType(): string;
 	 * @param TNodeType $node
 	 * @return list<IdentifierRuleError>
 	 */
-	public function processNode(Node $node, Scope&NodeCallbackInvoker $scope): array;
+	public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataEmitter $scope): array;
 
 }

src/Testing/CompositeRule.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Testing;
 
 use PhpParser\Node;
+use PHPStan\Analyser\CollectedDataEmitter;
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\DirectRegistry;
@@ -37,7 +38,7 @@ public function getNodeType(): string
 		return Node::class;
 	}
 
-	public function processNode(Node $node, Scope&NodeCallbackInvoker $scope): array
+	public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataEmitter $scope): array
 	{
 		$errors = [];
 

src/Testing/DelayedRule.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Testing;
 
 use PhpParser\Node;
+use PHPStan\Analyser\CollectedDataEmitter;
 use PHPStan\Analyser\NodeCallbackInvoker;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\DirectRegistry;
@@ -43,7 +44,7 @@ public function getDelayedErrors(): array
 		return $this->errors;
 	}
 
-	public function processNode(Node $node, Scope&NodeCallbackInvoker $scope): array
+	public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataEmitter $scope): array
 	{
 		$nodeType = get_class($node);
 		foreach ($this->registry->getRules($nodeType) as $rule) {

tests/PHPStan/Rules/CollectedDataEmitterRule.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules;
+
+use PhpParser\Node;
+use PHPStan\Analyser\CollectedDataEmitter;
+use PHPStan\Analyser\NodeCallbackInvoker;
+use PHPStan\Analyser\Scope;
+
+/**
+ * @implements Rule<Node\Expr\MethodCall>
+ */
+final class CollectedDataEmitterRule implements Rule
+{
+
+	public function getNodeType(): string
+	{
+		return Node\Expr\MethodCall::class;
+	}
+
+	public function processNode(Node $node, NodeCallbackInvoker&Scope&CollectedDataEmitter $scope): array
+	{
+		// same implementation as DummyCollector, but is actually a rule!
+		if (!$node->name instanceof Node\Identifier) {
+			return [];
+		}
+
+		$scope->emitCollectedData(DummyCollector::class, $node->name->toString());
+
+		return [];
+	}
+
+}

tests/PHPStan/Rules/CollectedDataEmitterTest.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules;
+
+use PHPStan\Testing\CompositeRule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<CompositeRule>
+ */
+class CollectedDataEmitterTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		// @phpstan-ignore argument.type
+		return new CompositeRule([
+			new CollectedDataEmitterRule(),
+			new DummyCollectorRule(),
+		]);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/dummy-collector.php'], [
+			[
+				'2× doFoo, 2× doBar',
+				5,
+			],
+		]);
+	}
+
+}