Inject ReflectionProvider and use Type system for plugin manager rule

Author: mglaman

extension.neon

@@ -39,7 +39,6 @@ parametersSchema:
 		))
 	])
 rules:
-	- mglaman\PHPStanDrupal\Rules\Classes\PluginManagerInspectionRule
 	- mglaman\PHPStanDrupal\Rules\Drupal\Coder\DiscouragedFunctionsRule
 	- mglaman\PHPStanDrupal\Rules\Drupal\GlobalDrupalDependencyInjectionRule
 	- mglaman\PHPStanDrupal\Rules\Drupal\PluginManager\PluginManagerSetsCacheBackendRule
@@ -84,6 +83,11 @@ services:
 		tags: [phpstan.rules.rule]
 		arguments:
 			reflectionProvider: @reflectionProvider
+	-
+		class: mglaman\PHPStanDrupal\Rules\Classes\PluginManagerInspectionRule
+		tags: [phpstan.rules.rule]
+		arguments:
+			reflectionProvider: @reflectionProvider
 	-
 		class: mglaman\PHPStanDrupal\Rules\Drupal\LoadIncludes
 		tags: [phpstan.rules.rule]

src/Rules/Classes/PluginManagerInspectionRule.php

@@ -4,27 +4,41 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\ObjectType;
 
+/**
+ * @implements \PHPStan\Rules\Rule<\PhpParser\Node\Stmt\Class_>
+ */
 class PluginManagerInspectionRule implements Rule
 {
+    /** @var ReflectionProvider */
+    private $reflectionProvider;
+    public function __construct(ReflectionProvider $reflectionProvider)
+    {
+        $this->reflectionProvider = $reflectionProvider;
+    }
+
     public function getNodeType(): string
     {
         return Node\Stmt\Class_::class;
     }
 
     public function processNode(Node $node, Scope $scope): array
     {
-        assert($node instanceof Node\Stmt\Class_);
-
+        if ($node->namespacedName === null) {
+            // anonymous class
+            return [];
+        }
         if ($node->extends === null) {
             return [];
         }
-
-        // If the class does not extend the default plugin manager, skip it.
-        // @todo inspect interfaces and see if it implements PluginManagerInterface.
-        if ($node->extends->toString() !== 'Drupal\Core\Plugin\DefaultPluginManager') {
+        $className = (string) $node->namespacedName;
+        $pluginManagerType = new ObjectType($className);
+        $pluginManagerInterfaceType = new ObjectType('\Drupal\Component\Plugin\PluginManagerInterface');
+        if (!$pluginManagerInterfaceType->isSuperTypeOf($pluginManagerType)->yes()) {
             return [];
         }
 
@@ -98,15 +112,11 @@ private function inspectYamlPluginManager(Node\Stmt\Class_ $class): array
     {
         $errors = [];
 
-        $fqn = $class->namespacedName;
-        $reflection = new \ReflectionClass($fqn->toString());
+        $fqn = (string) $class->namespacedName;
+        $reflection = $this->reflectionProvider->getClass($fqn);
         $constructor = $reflection->getConstructor();
 
-        if ($constructor === null) {
-            throw new ShouldNotHappenException();
-        }
-
-        if ($constructor->class !== $fqn->toString()) {
+        if ($constructor->getDeclaringClass()->getName() !== $fqn) {
             $errors[] = sprintf('%s must override __construct if using YAML plugins.', $fqn);
         } else {
             foreach ($class->stmts as $stmt) {

tests/fixtures/drupal/modules/phpstan_fixtures/src/ExamplePluginManager.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\phpstan_fixtures;
+
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Extension\ThemeHandlerInterface;
+use Drupal\Core\Plugin\DefaultPluginManager;
+use Drupal\Core\Plugin\Discovery\ContainerDerivativeDiscoveryDecorator;
+use Drupal\Core\Plugin\Discovery\YamlDiscovery;
+
+/**
+ * Provides the default example manager.
+ */
+class ExamplePluginManager extends DefaultPluginManager {
+
+    /**
+     * The theme handler.
+     *
+     * @var \Drupal\Core\Extension\ThemeHandlerInterface
+     */
+    protected $themeHandler;
+
+    /**
+     * Provides default values for all style_plugin plugins.
+     *
+     * @var array
+     */
+    protected $defaults = [
+        // Add required and optional plugin properties.
+        'id' => '',
+        'enabled' => TRUE,
+        'label' => '',
+        'description' => '',
+        'render' => [],
+    ];
+
+    /**
+     * Constructor.
+     *
+     * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+     *   The module handler.
+     * @param \Drupal\Core\Extension\ThemeHandlerInterface $theme_handler
+     *   The theme handler.
+     * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+     *   Cache backend instance to use.
+     */
+    public function __construct(
+        ModuleHandlerInterface $module_handler,
+        ThemeHandlerInterface $theme_handler,
+        CacheBackendInterface $cache_backend
+    ) {
+        $this->moduleHandler = $module_handler;
+        $this->themeHandler = $theme_handler;
+        $this->alterInfo('ui_examples_examples');
+        $this->setCacheBackend($cache_backend, 'ui_examples', ['ui_examples']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getDiscovery() {
+        $this->discovery = new YamlDiscovery('ui_examples', $this->moduleHandler->getModuleDirectories() + $this->themeHandler->getThemeDirectories());
+        $this->discovery->addTranslatableProperty('label', 'label_context');
+        $this->discovery->addTranslatableProperty('description', 'description_context');
+        $this->discovery = new ContainerDerivativeDiscoveryDecorator($this->discovery);
+        return $this->discovery;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function processDefinition(&$definition, $plugin_id) : void {
+        parent::processDefinition($definition, $plugin_id);
+        // @todo Add validation of the plugin definition here.
+        if (empty($definition['id'])) {
+            throw new PluginException(sprintf('Example plugin property (%s) definition "id" is required.', $plugin_id));
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function alterDefinitions(&$definitions) {
+        foreach ($definitions as $definition_key => $definition_info) {
+            if (isset($definition_info['enabled']) && !$definition_info['enabled']) {
+                unset($definitions[$definition_key]);
+                continue;
+            }
+        }
+
+        parent::alterDefinitions($definitions);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function providerExists($provider) : bool {
+        return $this->moduleHandler->moduleExists($provider) || $this->themeHandler->themeExists($provider);
+    }
+
+}

tests/src/Rules/PluginManagerInspectionRuleTest.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types=1);
+
+namespace mglaman\PHPStanDrupal\Tests\Rules;
+
+use mglaman\PHPStanDrupal\Rules\Classes\PluginManagerInspectionRule;
+use mglaman\PHPStanDrupal\Tests\DrupalRuleTestCase;
+
+final class PluginManagerInspectionRuleTest extends DrupalRuleTestCase
+{
+
+    protected function getRule(): \PHPStan\Rules\Rule
+    {
+        return new PluginManagerInspectionRule(
+            $this->createReflectionProvider()
+        );
+    }
+
+    /**
+     * @dataProvider pluginManagerData
+     */
+    public function testRule(string $path, array $errorMessages): void
+    {
+        $this->analyse([$path], $errorMessages);
+    }
+
+    public function pluginManagerData(): \Generator
+    {
+        yield 'BreakpointManager' => [
+            __DIR__ . '/../../fixtures/drupal/core/modules/breakpoint/src/BreakpointManager.php',
+            []
+        ];
+        yield 'ExamplePluginManager' => [
+            __DIR__ . '/../../fixtures/drupal/modules/phpstan_fixtures/src/ExamplePluginManager.php',
+            []
+        ];
+    }
+
+}