Use our own collectors for traits. Add excluded framework base classes and custom excluded base classes.

Author: ianef

README.md

@@ -24,6 +24,7 @@ include:
 ```
 
 ## Rules
+---
 ### `UnusedClassRule`
 This rule scans for class declarations and use statements. If a class is declared but not used within the scanned source files, an error is generated.
 
@@ -48,6 +49,32 @@ parameters:
             - 'src/MyUnusedClass.php'
 ```
 
+### Excluding Services
+By default, some known service and framework classes are excluded. There are a number of base classes from Symfony, Doctrine and PHPUnit that checked and, if matched, the class being analysed is ignored.
+
+To disable this, set the *excludeFrameworks* property to false:
+```yaml
+# phpstan.neon
+parameters:
+    unused_classes:
+        excludeFrameworks: false
+```
+
+This list will change as new frameworks and classes are added. Please look at the source code in src/Frameworks for a list of base classes that are excluded.
+
+If you want add a custom list of base classes to ignore, use the *baseClassExcludes* property:
+```yaml
+# phpstan.neon
+parameters:
+    unused_classes:
+        baseClassExcludes:
+            - 'App\Service\MyAbstractService'
+            - 'App\DI\MyDIClass'
+```
+
+Entries in *baseClassExcludes* are excluded regardless of the *excludeFrameworks* property value.
+
+---
 ### `UnusedTraitRule`
 This rule scans for trait declarations and use statements. If a trait is declared but not used within the scanned source files, an error is generated.
 
@@ -61,4 +88,4 @@ parameters:
 ```
 
 #### Excluding files
-You can exclude directories and individual files from being scanned by this rule using the excludePaths parameter as shown above/
+You can exclude directories and individual files from being scanned by this rule using the excludePaths parameter as shown above.

config/extension.neon

@@ -3,6 +3,8 @@ parametersSchema:
         classes: bool()
         traits: bool()
         excludePaths: array()
+        excludeFrameworks: bool()
+        baseClassExcludes: array()
     ])
 
 # default parameters
@@ -11,6 +13,8 @@ parameters:
         classes: true
         traits: true
         excludePaths: []
+        excludeFrameworks: true
+        baseClassExcludes: []
 
 services:
     -
@@ -31,6 +35,14 @@ services:
         class: Xact\PHPStan\Collectors\DeclareClassCollector
         tags:
             - phpstan.collector
+    -
+        class: Xact\PHPStan\Collectors\DeclareTraitCollector
+        tags:
+            - phpstan.collector
+    -
+        class: Xact\PHPStan\Collectors\TraitUseCollector
+        tags:
+            - phpstan.collector
 
 rules:
     - Xact\PHPStan\Rules\UnusedClassRule

src/Collectors/TraitUseCollector.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xact\PHPStan\Collectors;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\TraitUse;
+use PhpParser\Node\Stmt\Use_ ;
+use PHPStan\Analyser\Scope;
+use PHPStan\Collectors\Collector;
+use Xact\PHPStan\Exception\InvalidNodeTypeException;
+
+class TraitUseCollector implements Collector
+{
+    public function getNodeType(): string
+    {
+        return TraitUse ::class;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    // phpcs:ignore SlevomatCodingStandard.Functions.UnusedParameter.UnusedParameter
+    public function processNode(Node $node, Scope $scope)
+    {
+        if (!$node instanceof TraitUse) {
+            throw InvalidNodeTypeException::create($node, Use_::class);
+        }
+
+        $uses = [];
+        foreach ($node->traits as $traitNodeName) {
+            $traitName = $traitNodeName->toString();
+            $uses[$traitName] = $traitName;
+        }
+
+        // returns an array of used trait names
+        return $uses;
+    }
+}

src/Configuration.php

@@ -41,4 +41,22 @@ public function getExcludePaths(): array
 
         return $excludePaths;
     }
+
+    public function isExcludeFrameworks(): bool
+    {
+        return (bool)($this->parameters['excludeFrameworks'] ?? true);
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getBaseClassExcludes(): array
+    {
+        /** @var string[] */
+        $frameworkClasses = $this->parameters['baseClassExcludes'] ?? $this->parameters['baseClassExcludes'];
+
+        Assert::isArray($frameworkClasses);
+
+        return $frameworkClasses;
+    }
 }

src/Frameworks/Doctrine.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xact\PHPStan\Frameworks;
+
+final class Doctrine
+{
+    /** @var string[] */
+    public static array $classes = [
+        'Doctrine\Common\DataFixtures\AbstractFixture',
+        'Doctrine\DBAL\Types\Type',
+        'Doctrine\ORM\Query\AST\Node',
+    ];
+}

src/Frameworks/PHPUnit.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xact\PHPStan\Frameworks;
+
+class PHPUnit
+{
+    /** @var string[] */
+    public static array $classes = [
+        'PHPUnit\Framework\TestCase',
+    ];
+}

src/Frameworks/Symfony.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xact\PHPStan\Frameworks;
+
+final class Symfony
+{
+    /** @var string[] */
+    public static array $classes = [
+        'Symfony\Bundle\FrameworkBundle\Controller\AbstractController',
+        'Symfony\Component\Console\Command\Command',
+        'Symfony\Component\HttpKernel\Bundle\Bundle',
+        'Symfony\Component\HttpKernel\Kernel',
+        'Symfony\Component\Validator\Constraint',
+        'Symfony\Component\Validator\ConstraintValidator',
+        'Twig\Extension\AbstractExtension',
+    ];
+}

src/Rules/UnusedClassRule.php

@@ -7,15 +7,29 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
+use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use Xact\PHPStan\Collectors\ClassGroupUseCollector;
 use Xact\PHPStan\Collectors\ClassUseCollector;
 use Xact\PHPStan\Collectors\DeclareClassCollector;
+use Xact\PHPStan\Configuration;
 use Xact\PHPStan\Exception\InvalidNodeTypeException;
+use Xact\PHPStan\Frameworks\Doctrine;
+use Xact\PHPStan\Frameworks\PHPUnit;
+use Xact\PHPStan\Frameworks\Symfony;
 
 class UnusedClassRule implements Rule
 {
+    private Configuration $configuration;
+    private ReflectionProvider $reflectionProvider;
+
+    public function __construct(Configuration $configuration, ReflectionProvider $reflectionProvider)
+    {
+        $this->configuration = $configuration;
+        $this->reflectionProvider = $reflectionProvider;
+    }
+
     /**
      * @inheritDoc
      */
@@ -65,6 +79,10 @@ public function processNode(Node $node, Scope $scope): array
              * @var int $line
              */
             foreach ($declarations as [$className, $line]) {
+                if ($this->isKnownFrameworkService($className)) {
+                    continue;
+                }
+
                 if (!array_key_exists($className, $usedClasses)) {
                     $errors[] = RuleErrorBuilder::message("Class {$className} is never used.")
                         ->file($file)
@@ -76,4 +94,33 @@ public function processNode(Node $node, Scope $scope): array
 
         return $errors;
     }
+
+    private function isKnownFrameworkService(string $className): bool
+    {
+        if ($this->configuration->isExcludeFrameworks() === false && count($this->configuration->getBaseClassExcludes()) === 0) {
+            return false;
+        }
+        if ($this->reflectionProvider->hasClass($className) === false) {
+            return false;
+        }
+
+        $excludedClasses = $this->configuration->getBaseClassExcludes();
+        if ($this->configuration->isExcludeFrameworks() === true) {
+            $excludedClasses = array_merge(
+                $excludedClasses,
+                Symfony::$classes,
+                Doctrine::$classes,
+                PHPUnit::$classes,
+            );
+        }
+        // Does the class name extend a known framework base class that is not directly used in client code?
+        $reflection = $this->reflectionProvider->getClass($className);
+        foreach ($reflection->getParentClassesNames() as $parentName) {
+            if (in_array($parentName, $excludedClasses)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

src/Rules/UnusedTraitRule.php

@@ -9,8 +9,8 @@
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
-use PHPStan\Rules\Traits\TraitDeclarationCollector;
-use PHPStan\Rules\Traits\TraitUseCollector;
+use Xact\PHPStan\Collectors\DeclareTraitCollector;
+use Xact\PHPStan\Collectors\TraitUseCollector;
 use Xact\PHPStan\Exception\InvalidNodeTypeException;
 
 class UnusedTraitRule implements Rule
@@ -37,7 +37,7 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        $traitDeclarationData = $node->get(TraitDeclarationCollector::class);
+        $traitDeclarationData = $node->get(DeclareTraitCollector::class);
         $traitUses = $node->get(TraitUseCollector::class);
 
         $usedTraits = [];

tests/UnusedClassTest.php

@@ -31,16 +31,19 @@ public function testRule(): void
         // first argument: path to the example file that contains some errors that should be reported by UnusedClassRule
         // second argument: an array of expected errors,
         // each error consists of the asserted error message, and the asserted error file line
-        $this->analyse([__DIR__ . '/UnusedClass/ClassA.php', __DIR__ . '/UnusedClass/ClassB.php', __DIR__ . '/UnusedClass/ClassC.php'], [
+        $this->analyse(
+            [__DIR__ . '/UnusedClass/ClassA.php', __DIR__ . '/UnusedClass/ClassB.php', __DIR__ . '/UnusedClass/ClassC.php'],
             [
-                'Class Xact\PHPStan\Tests\UnusedClass\ClassA is never used.', // asserted error message
-                9, // asserted error line
-            ],
-            [
-                'Class Xact\PHPStan\Tests\UnusedClass\ClassC is never used.', // asserted error message
-                9, // asserted error line
-            ],
-        ]);
+                [
+                    'Class Xact\PHPStan\Tests\UnusedClass\ClassA is never used.', // asserted error message
+                    9, // asserted error line
+                ],
+                [
+                    'Class Xact\PHPStan\Tests\UnusedClass\ClassC is never used.', // asserted error message
+                    9, // asserted error line
+                ],
+            ]
+        );
 
         // the test fails, if the expected error does not occur,
         // or if there are other errors reported beside the expected one
@@ -49,7 +52,7 @@ public function testRule(): void
     protected function getRule(): Rule
     {
         // getRule() method needs to return an instance of the tested rule
-        return new UnusedClassRule();
+        return self::getContainer()->getByType(UnusedClassRule::class);
     }
 
     /**