[dx] show type coverage only if full paths are analysed, to avoid spamming output (#51)

* Return always RuleError objects

* [dx] show type coverage only if full paths are analysed, to avoid spamming output

* skip in tests

* cache

Author: TomasVotruba

README.md

@@ -111,4 +111,22 @@ parameters:
 
 <br>
 
+## Full Paths only
+
+If you run PHPStan only on some subpaths that are different from your setup in `phpstan.neon`, e.g.:
+
+```bash
+vendor/bin/phpstan analyze src/Controller
+```
+
+This package could show false positives, as classes in the `src/Controller` could be slightly less typed. This would be spamming whole PHPStan output and make hard to see any other errors you look for.
+
+That's why this package only triggers if there are full paths, e.g.:
+
+```bash
+vendor/bin/phpstan
+````
+
+<br>
+
 Happy coding!

composer.json

@@ -6,13 +6,13 @@
     "keywords": ["static analysis", "phpstan-extension"],
     "require": {
         "php": "^8.2",
-        "phpstan/phpstan": "^2.0.3"
+        "phpstan/phpstan": "^2.1.1"
     },
     "require-dev": {
         "phpstan/extension-installer": "^1.4",
         "phpunit/phpunit": "^11.5",
-        "symplify/easy-coding-standard": "^12.4",
-        "rector/rector": "^2.0",
+        "symplify/easy-coding-standard": "^12.5",
+        "rector/rector": "^2.0.6",
         "tracy/tracy": "^2.10",
         "tomasvotruba/unused-public": "^2.0"
     },

phpstan.neon

@@ -27,6 +27,19 @@ parameters:
         # used in tests
         - message: '#Public constant "TomasVotruba\\TypeCoverage\\(.*?)::ERROR_MESSAGE" is never#'
 
+        # needed to access metadata about paths
+        -
+            message: '#PHPStan\\Analyser\\LazyInternalScopeFactory#'
+            identifier: phpstanApi.class
+
+        -
+            message: '#PHPStan\\DependencyInjection\\Nette\\NetteContainer#'
+            identifier: phpstanApi.method
+
+        -
+            message: '#PHPStan\\DependencyInjection\\MemoizingContainer#'
+            identifier: phpstanApi.class
+
     excludePaths:
         - "*/Fixture/*"
         - "*/Source/*"

src/Configuration/ScopeConfigurationResolver.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TomasVotruba\TypeCoverage\Configuration;
+
+use PHPStan\Analyser\LazyInternalScopeFactory;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\MemoizingContainer;
+use PHPStan\DependencyInjection\Nette\NetteContainer;
+use ReflectionProperty;
+
+/**
+ * The easiest way to reach project configuration from Scope object
+ */
+final class ScopeConfigurationResolver
+{
+    private static ?bool $areFullPathsAnalysed = null;
+
+    public static function areFullPathsAnalysed(Scope $scope): bool
+    {
+        // cache for speed
+        if (self::$areFullPathsAnalysed !== null) {
+            return self::$areFullPathsAnalysed;
+        }
+
+        $scopeFactory = self::getPrivateProperty($scope, 'scopeFactory');
+
+        // different types are used in tests, there we want to always analyse everything
+        if (! $scopeFactory instanceof LazyInternalScopeFactory) {
+            return true;
+        }
+
+        $scopeFactoryContainer = self::getPrivateProperty($scopeFactory, 'container');
+        if (! $scopeFactoryContainer instanceof MemoizingContainer) {
+            // edge case, unable to analyse
+            return true;
+        }
+
+        /** @var NetteContainer $originalContainer */
+        $originalContainer = self::getPrivateProperty($scopeFactoryContainer, 'originalContainer');
+
+        $analysedPaths = $originalContainer->getParameter('analysedPaths');
+        $analysedPathsFromConfig = $originalContainer->getParameter('analysedPathsFromConfig');
+
+        self::$areFullPathsAnalysed = $analysedPathsFromConfig === $analysedPaths;
+
+        return self::$areFullPathsAnalysed;
+    }
+
+    private static function getPrivateProperty(object $object, string $propertyName): object
+    {
+        $reflectionProperty = new ReflectionProperty($object, $propertyName);
+
+        return $reflectionProperty->getValue($object);
+    }
+}

src/Rules/ConstantTypeCoverageRule.php

@@ -8,9 +8,12 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use TomasVotruba\TypeCoverage\CollectorDataNormalizer;
 use TomasVotruba\TypeCoverage\Collectors\ConstantTypeDeclarationCollector;
 use TomasVotruba\TypeCoverage\Configuration;
+use TomasVotruba\TypeCoverage\Configuration\ScopeConfigurationResolver;
 use TomasVotruba\TypeCoverage\Formatter\TypeCoverageFormatter;
 
 /**
@@ -47,21 +50,26 @@ public function getNodeType(): string
 
     /**
      * @param CollectedDataNode $node
-     * @return mixed[]
+     * @return RuleError[]
      */
     public function processNode(Node $node, Scope $scope): array
     {
+        // if only subpaths are analysed, skip as data will be false positive
+        if (! ScopeConfigurationResolver::areFullPathsAnalysed($scope)) {
+            return [];
+        }
+
         $constantTypeDeclarationCollector = $node->get(ConstantTypeDeclarationCollector::class);
         $typeCountAndMissingTypes = $this->collectorDataNormalizer->normalize($constantTypeDeclarationCollector);
 
         if ($this->configuration->showOnlyMeasure()) {
-            return [
-                sprintf(
-                    'Class constant type coverage is %.1f %% out of %d possible',
-                    $typeCountAndMissingTypes->getCoveragePercentage(),
-                    $typeCountAndMissingTypes->getTotalCount()
-                ),
-            ];
+            $errorMessage = sprintf(
+                'Class constant type coverage is %.1f %% out of %d possible',
+                $typeCountAndMissingTypes->getCoveragePercentage(),
+                $typeCountAndMissingTypes->getTotalCount()
+            );
+
+            return [RuleErrorBuilder::message($errorMessage)->build()];
         }
 
         if (! $this->configuration->isConstantTypeCoverageEnabled()) {

src/Rules/DeclareCoverageRule.php

@@ -8,9 +8,11 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 use TomasVotruba\TypeCoverage\Collectors\DeclareCollector;
 use TomasVotruba\TypeCoverage\Configuration;
+use TomasVotruba\TypeCoverage\Configuration\ScopeConfigurationResolver;
 
 /**
  * @see \TomasVotruba\TypeCoverage\Tests\Rules\DeclareCoverageRule\DeclareCoverageRuleTest
@@ -39,10 +41,15 @@ public function getNodeType(): string
 
     /**
      * @param CollectedDataNode $node
-     * @return mixed[]
+     * @return RuleError[]
      */
     public function processNode(Node $node, Scope $scope): array
     {
+        // if only subpaths are analysed, skip as data will be false positive
+        if (! ScopeConfigurationResolver::areFullPathsAnalysed($scope)) {
+            return [];
+        }
+
         $requiredDeclareLevel = $this->configuration->getRequiredDeclareLevel();
 
         $declareCollector = $node->get(DeclareCollector::class);
@@ -63,13 +70,12 @@ public function processNode(Node $node, Scope $scope): array
         $declareCoverage = ($coveredDeclares / $totalPossibleDeclares) * 100;
 
         if ($this->configuration->showOnlyMeasure()) {
-            return [
-                sprintf(
-                    'Strict declares coverage is %.1f %% out of %d possible',
-                    $declareCoverage,
-                    $totalPossibleDeclares
-                ),
-            ];
+            $errorMessage = sprintf(
+                'Strict declares coverage is %.1f %% out of %d possible',
+                $declareCoverage,
+                $totalPossibleDeclares
+            );
+            return [RuleErrorBuilder::message($errorMessage)->build()];
         }
 
         // not enabled

src/Rules/ParamTypeCoverageRule.php

@@ -8,9 +8,12 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use TomasVotruba\TypeCoverage\CollectorDataNormalizer;
 use TomasVotruba\TypeCoverage\Collectors\ParamTypeDeclarationCollector;
 use TomasVotruba\TypeCoverage\Configuration;
+use TomasVotruba\TypeCoverage\Configuration\ScopeConfigurationResolver;
 use TomasVotruba\TypeCoverage\Formatter\TypeCoverageFormatter;
 
 /**
@@ -47,22 +50,30 @@ public function getNodeType(): string
 
     /**
      * @param CollectedDataNode $node
-     * @return mixed[]
+     * @return RuleError[]
      */
     public function processNode(Node $node, Scope $scope): array
     {
+        // if only subpaths are analysed, skip as data will be false positive
+        if (! ScopeConfigurationResolver::areFullPathsAnalysed($scope)) {
+            return [];
+        }
+
         $paramTypeDeclarationCollector = $node->get(ParamTypeDeclarationCollector::class);
 
         $typeCountAndMissingTypes = $this->collectorDataNormalizer->normalize($paramTypeDeclarationCollector);
 
         if ($this->configuration->showOnlyMeasure()) {
-            return [
-                sprintf(
-                    'Param type coverage is %.1f %% out of %d possible',
-                    $typeCountAndMissingTypes->getCoveragePercentage(),
-                    $typeCountAndMissingTypes->getTotalCount()
-                ),
-            ];
+            $errorMessage = sprintf(
+                'Param type coverage is %.1f %% out of %d possible',
+                $typeCountAndMissingTypes->getCoveragePercentage(),
+                $typeCountAndMissingTypes->getTotalCount()
+            );
+
+            $ruleError = RuleErrorBuilder::message($errorMessage)
+                ->build();
+
+            return [$ruleError];
         }
 
         if ($this->configuration->getRequiredParamTypeLevel() === 0) {

src/Rules/PropertyTypeCoverageRule.php

@@ -8,9 +8,12 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use TomasVotruba\TypeCoverage\CollectorDataNormalizer;
 use TomasVotruba\TypeCoverage\Collectors\PropertyTypeDeclarationCollector;
 use TomasVotruba\TypeCoverage\Configuration;
+use TomasVotruba\TypeCoverage\Configuration\ScopeConfigurationResolver;
 use TomasVotruba\TypeCoverage\Formatter\TypeCoverageFormatter;
 
 /**
@@ -47,21 +50,26 @@ public function getNodeType(): string
 
     /**
      * @param CollectedDataNode $node
-     * @return mixed[]
+     * @return RuleError[]
      */
     public function processNode(Node $node, Scope $scope): array
     {
+        // if only subpaths are analysed, skip as data will be false positive
+        if (! ScopeConfigurationResolver::areFullPathsAnalysed($scope)) {
+            return [];
+        }
+
         $propertyTypeDeclarationCollector = $node->get(PropertyTypeDeclarationCollector::class);
         $typeCountAndMissingTypes = $this->collectorDataNormalizer->normalize($propertyTypeDeclarationCollector);
 
         if ($this->configuration->showOnlyMeasure()) {
-            return [
-                sprintf(
-                    'Property type coverage is %.1f %% out of %d possible',
-                    $typeCountAndMissingTypes->getCoveragePercentage(),
-                    $typeCountAndMissingTypes->getTotalCount()
-                ),
-            ];
+            $errorMessage = sprintf(
+                'Property type coverage is %.1f %% out of %d possible',
+                $typeCountAndMissingTypes->getCoveragePercentage(),
+                $typeCountAndMissingTypes->getTotalCount()
+            );
+
+            return [RuleErrorBuilder::message($errorMessage)->build()];
         }
 
         if ($this->configuration->getRequiredPropertyTypeLevel() === 0) {

src/Rules/ReturnTypeCoverageRule.php

@@ -8,9 +8,12 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\CollectedDataNode;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use TomasVotruba\TypeCoverage\CollectorDataNormalizer;
 use TomasVotruba\TypeCoverage\Collectors\ReturnTypeDeclarationCollector;
 use TomasVotruba\TypeCoverage\Configuration;
+use TomasVotruba\TypeCoverage\Configuration\ScopeConfigurationResolver;
 use TomasVotruba\TypeCoverage\Formatter\TypeCoverageFormatter;
 
 /**
@@ -47,21 +50,25 @@ public function getNodeType(): string
 
     /**
      * @param CollectedDataNode $node
-     * @return mixed[]
+     * @return RuleError[]
      */
     public function processNode(Node $node, Scope $scope): array
     {
+        // if only subpaths are analysed, skip as data will be false positive
+        if (! ScopeConfigurationResolver::areFullPathsAnalysed($scope)) {
+            return [];
+        }
+
         $returnSeaLevelDataByFilePath = $node->get(ReturnTypeDeclarationCollector::class);
         $typeCountAndMissingTypes = $this->collectorDataNormalizer->normalize($returnSeaLevelDataByFilePath);
 
         if ($this->configuration->showOnlyMeasure()) {
-            return [
-                sprintf(
-                    'Return type coverage is %.1f %% out of %d possible',
-                    $typeCountAndMissingTypes->getCoveragePercentage(),
-                    $typeCountAndMissingTypes->getTotalCount()
-                ),
-            ];
+            $errorMessage = sprintf(
+                'Return type coverage is %.1f %% out of %d possible',
+                $typeCountAndMissingTypes->getCoveragePercentage(),
+                $typeCountAndMissingTypes->getTotalCount()
+            );
+            return [RuleErrorBuilder::message($errorMessage)->build()];
         }
 
         if ($this->configuration->getRequiredReturnTypeLevel() === 0) {