Add scanning for traits, and config settings to disable scanning for classes and traits.

Author: ianef

README.md

@@ -24,7 +24,17 @@ 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.
+This rule scans for class and trait declarations and use statements. If a class or trait is declared but not used within the scanned source files, an error is generated.
+
+### Disabling the rule
+You can disable scanning classes and traits as follows:
+```yaml
+# phpstan.neon
+parameters:
+    unused_classes:
+        classes: false
+        traits: false
+```
 
 #### Excluding files
 You can exclude directories and individual files from being scanned by this rule:
@@ -33,8 +43,7 @@ You can exclude directories and individual files from being scanned by this rule
 # phpstan.neon
 parameters:
     unused_classes:
-        - 'src/Entity'
-        - 'src/Controller'
-        - 'src/Repositories'
-        - 'src/MyUnusedClass.php'
+        excludePaths:
+            - 'src/Controller'
+            - 'src/MyUnusedClass.php'
 ```

config/extension.neon

@@ -1,12 +1,16 @@
 parametersSchema:
     unused_classes: structure([
-        excludedPaths: array()
+        classes: bool()
+        traits: bool()
+        excludePaths: array()
     ])
 
 # default parameters
 parameters:
     unused_classes:
-        excludedPaths: []
+        classes: true
+        traits: true
+        excludePaths: []
 
 services:
     -
@@ -27,6 +31,10 @@ services:
         class: Xact\PHPStan\Collectors\DeclareClassCollector
         tags:
             - phpstan.collector
+    -
+        class: Xact\PHPStan\Collectors\DeclareTraitCollector
+        tags:
+            - phpstan.collector
 
 rules:
     - Xact\PHPStan\Rules\UnusedClassRule

src/Collectors/DeclareClassCollector.php

@@ -52,8 +52,12 @@ public function processNode(Node $node, Scope $scope)
 
     private function isFileExcluded(Scope $scope): bool
     {
-        $excludedPaths = $this->configuration->getExcludedPaths();
-        foreach ($excludedPaths as $path) {
+        if ($this->configuration->isUnusedClassesEnabled() === false) {
+            return true;
+        }
+
+        $excludePaths = $this->configuration->getExcludePaths();
+        foreach ($excludePaths as $path) {
             $excludePath = $this->fileHelper->absolutizePath($path);
             if (str_starts_with($scope->getFile(), $excludePath)) {
                 return true;

src/Collectors/DeclareTraitCollector.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Xact\PHPStan\Collectors;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Trait_;
+use PHPStan\Analyser\Scope;
+use PHPStan\Collectors\Collector;
+use PHPStan\File\FileHelper;
+use Xact\PHPStan\Configuration;
+use Xact\PHPStan\Exception\InvalidNodeTypeException;
+
+class DeclareTraitCollector implements Collector
+{
+    private Configuration $configuration;
+    private FileHelper $fileHelper;
+
+    public function __construct(Configuration $configuration, FileHelper $fileHelper)
+    {
+        $this->configuration = $configuration;
+        $this->fileHelper = $fileHelper;
+    }
+
+    public function getNodeType(): string
+    {
+        return Trait_::class;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    // phpcs:ignore SlevomatCodingStandard.Functions.UnusedParameter.UnusedParameter
+    public function processNode(Node $node, Scope $scope)
+    {
+        if (!$node instanceof Trait_) {
+            throw InvalidNodeTypeException::create($node, Trait_::class);
+        }
+
+        if ($node->namespacedName === null) {
+            return null;
+        }
+
+        if ($this->isFileExcluded($scope)) {
+            return null;
+        }
+
+        // returns an array with class name and line - array{string, int}
+        return [$node->namespacedName->toString(), $node->getLine()];
+    }
+
+    private function isFileExcluded(Scope $scope): bool
+    {
+        if ($this->configuration->isUnusedTraitsEnabled() === false) {
+            return true;
+        }
+
+        $excludePaths = $this->configuration->getExcludePaths();
+        foreach ($excludePaths as $path) {
+            $excludePath = $this->fileHelper->absolutizePath($path);
+            if (str_starts_with($scope->getFile(), $excludePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/Configuration.php

@@ -19,16 +19,26 @@ public function __construct(array $parameters)
         $this->parameters = $parameters;
     }
 
+    public function isUnusedClassesEnabled(): bool
+    {
+        return (bool)($this->parameters['classes'] ?? true);
+    }
+
+    public function isUnusedTraitsEnabled(): bool
+    {
+        return (bool)($this->parameters['traits'] ?? true);
+    }
+
     /**
      * @return string[]
      */
-    public function getExcludedPaths(): array
+    public function getExcludePaths(): array
     {
         /** @var string[] */
-        $excludedPaths = $this->parameters['excludedPaths'] ?? $this->parameters['excludedPaths'];
+        $excludePaths = $this->parameters['excludePaths'] ?? $this->parameters['excludePaths'];
 
-        Assert::allFileExists($excludedPaths);
+        Assert::allFileExists($excludePaths);
 
-        return $excludedPaths;
+        return $excludePaths;
     }
 }

src/Rules/UnusedClassRule.php

@@ -12,6 +12,7 @@
 use Xact\PHPStan\Collectors\ClassGroupUseCollector;
 use Xact\PHPStan\Collectors\ClassUseCollector;
 use Xact\PHPStan\Collectors\DeclareClassCollector;
+use Xact\PHPStan\Collectors\DeclareTraitCollector;
 use Xact\PHPStan\Exception\InvalidNodeTypeException;
 
 class UnusedClassRule implements Rule
@@ -35,6 +36,7 @@ public function processNode(Node $node, Scope $scope): array
         }
 
         $classDeclarationData = $node->get(DeclareClassCollector::class);
+        $traitDeclarationData = $node->get(DeclareTraitCollector::class);
         $groupUses = $node->get(ClassGroupUseCollector::class);
         $normalUses = $node->get(ClassUseCollector::class);
 
@@ -69,6 +71,20 @@ public function processNode(Node $node, Scope $scope): array
                 }
             }
         }
+        foreach ($traitDeclarationData as $file => $declarations) {
+            /**
+             * @var string $className
+             * @var int $line
+             */
+            foreach ($declarations as [$className, $line]) {
+                if (!array_key_exists($className, $usedClasses)) {
+                    $errors[] = RuleErrorBuilder::message("Trait {$className} is never used.")
+                        ->file($file)
+                        ->line($line)
+                        ->build();
+                }
+            }
+        }
 
         return $errors;
     }