Register each tagged service once, add PHPStan rule to keep it that way

[TomasVotruba]

I went looking at LazyContainerFactory::create() because it is a 320-line method, and found two duplicate registrations hiding in it. The second commit adds a PHPStan rule so they cannot come back.

Every phpdoc node visitor was registered twice

self::BASE_PHP_DOC_NODE_VISITORS is passed to registerTagged() in two separate places — once in the multi-line block, and again 18 lines later in the one-liner block:

$this->registerTagged(
    $rectorConfig,
    self::BASE_PHP_DOC_NODE_VISITORS,
    BasePhpDocNodeVisitorInterface::class
);

// PHP 8.0 attributes
// ...

$this->registerTagged($rectorConfig, self::OUTPUT_FORMATTER_CLASSES, OutputFormatterInterface::class);
$this->registerTagged($rectorConfig, self::BASE_PHP_DOC_NODE_VISITORS, BasePhpDocNodeVisitorInterface::class);

registerTagged() calls $container->tag(), which appends, so the tag collection ends up holding each class twice. PhpDocNodeMapper takes its $phpDocNodeVisitors from that tag:

before: resolved visitors: 10
DUPLICATE x2  ArrayTypePhpDocNodeVisitor
DUPLICATE x2  CallableTypePhpDocNodeVisitor
DUPLICATE x2  IntersectionTypeNodePhpDocNodeVisitor
DUPLICATE x2  TemplatePhpDocNodeVisitor
DUPLICATE x2  UnionTypeNodePhpDocNodeVisitor

after:  resolved visitors: 5

They are the same singleton instances, so this is duplicated traversal work on every doc node of every file rather than corrupted state — the full test suite produces identical results before and after.

DynamicSourceLocatorProvider was tagged on top of autotagging

$rectorConfig->tag(DynamicSourceLocatorProvider::class, ResettableInterface::class);

RectorConfig already autotags ResettableInterface ($autotagInterfaces), and this class is registered via singleton() a few lines below, so the explicit tag is a second registration. It got reset twice on every AbstractRectorTestCase boot. The neighbouring RenamedClassesDataCollector line is not redundant — it is never registered through singleton(), so autotagging never fires for it and the explicit tag is what puts it in the collection. Only the one line is removed.

Runtime test

A test asserts no tag collection holds the same class twice. It fails on both counts without this fix:

 Array &0 [
      0 => 'Rector\PostRector\Application\PostFileProcessor',
      1 => '...\DynamicSourceLocatorProvider',
 -    2 => 'Rector\Configuration\RenamedClassesDataCollector',
 +    2 => '...\DynamicSourceLocatorProvider',
 +    3 => 'Rector\Configuration\RenamedClassesDataCollector',
  ]

PHPStan rule

SingleServiceRegistrationRule catches the same class of mistake at analysis time, in any registration method:

$rectorConfig->singleton(SomeService::class);
$rectorConfig->tag(SomeOtherService::class, SomeTagInterface::class);

$rectorConfig->tag(SomeOtherService::class, SomeTagInterface::class);
// "tag(SomeOtherService, SomeTagInterface)" is already called on line 25; register the service exactly once.

$rectorConfig->tag(SomeService::class, ResettableInterface::class);
// Service "SomeService" is registered as singleton and "ResettableInterface" is autotagged,
// so this tag() call registers it twice.

It tracks singleton(), tag() and registerTagged() calls within one method, keyed by the arguments that identify the service — the container argument itself is excluded, so registerTagged($rectorConfig, X, Y) compares on X, Y.

Checked against the unfixed file: it reports the duplicated registerTagged(self::BASE_PHP_DOC_NODE_VISITORS) on line 613 and the redundant DynamicSourceLocatorProvider tag on line 481. Running it over the whole codebase produces no other errors.

One implementation note worth recording: the Scope handed to a ClassMethod rule is the scope at method entry, where body variables are still mixed. Gating on $scope->getType($rectorConfig) being a Container silently matched almost nothing — it dropped 27 of the 30 registration calls in create() while still passing its own fixtures. The rule matches on call shape instead.

Scope note

The runtime test and the PHPStan rule cover different things and both are kept: the rule sees source-level repetition in any method, the test sees the resulting container, including tags that arrive through autotagging rather than an explicit call.