dead code detector

Détecteur de code mort pour PHP

Extension phpstan pour trouver facilement du code PHP inutilisé dans votre projet!

Résumé:

• ✅ Extension phpstan
• ♻️ Détection des cycles morts
• ? Détection de membres morts transitifs
• ? Suppression automatique du code inutilisé
• Support de bibliothèques populaires
• Fournisseurs d'utilisation personnalisables

Installation:

composer require --dev shipmonk/dead-code-detector

Utilisez l'installateur d'extension officiel ou chargez simplement les règles:

 # phpstan.neon.dist
includes :
    - vendor/shipmonk/dead-code-detector/rules.neon 

Bibliothèques prises en charge:

Symfony:

• Appels passés par DIC sur vos services!
  • constructeurs, appels, méthodes d'usine
  • phpstan/phpstan-symfony avec containerXmlPath doit être utilisé
• #[AsEventListener] Attribut
• #[AsController] Attribut
• #[AsCommand] Attribut
• #[Required] Attribut
• #[Route] Attributs
• EventSubscriberInterface::getSubscribedEvents
• onKernelResponse , onKernelRequest , etc.

Doctrine:

• #[AsEntityListener] Attribut
• DoctrineORMEvents::* Events
• DoctrineCommonEventSubscriber Methods
• Attributs d'événements de cycle de vie #[PreFlush] , #[PostLoad] , ...

Phpunit:

• Méthodes du fournisseur de données
• Méthodes testXxx
• Annotations comme @test , @before , @afterClass etc
• Attributs comme #[Test] , #[Before] , #[AfterClass] etc.

Phpstan:

• Le constructeur appelle des services DIC (règles, extensions, ...)

Nette:

• handleXxx , renderXxx , actionXxx , injectXxx , createComponentXxx
• SmartObject Magic appelle des annotations @property

Toutes ces bibliothèques sont auto-activées lorsqu'elles sont trouvées dans vos dépendances de compositeur. Si vous souhaitez forcer à activer / en désactiver certains, vous pouvez:

 # phpstan.neon.dist
parameters :
    shipmonkDeadCode :
        usageProviders :
            phpunit :
                enabled : true 

Fournisseurs d'utilisation générique:

Réflexion:

• Toute constante ou méthode accessible via ReflectionClass est détectée comme utilisée
  • Eg $reflection->getConstructor() , $reflection->getConstant('NAME') , $reflection->getMethods() , ...

Fournisseur:

• Toute méthode remplacée qui provient du vendor n'est pas signalée comme mort
  • par exemple implémentation PsrLogLoggerInterface::log est automatiquement considéré comme utilisé

Ces fournisseurs sont activés par défaut, mais vous pouvez les désactiver si nécessaire.

Personnalisation:

• Si votre application fait des appels magiques inconnus à cette bibliothèque, vous pouvez implémenter votre propre fournisseur d'utilisation.
• Il suffit de le marquer avec shipmonk.deadCode.memberUsageProvider et implémenter ShipMonkPHPStanDeadCodeProviderMemberUsageProvider

 # phpstan.neon.dist
services :
    -
        class : AppApiOutputUsageProvider
        tags :
            - shipmonk.deadCode.memberUsageProvider 

Important

L'interface et la balise ont changé en 0,7. Si vous utilisez PHPSTAN 1.x, ceux-ci ont été utilisés différemment.

Personnalisation basée sur la réflexion:

• Pour les usées de réflexion simples, vous pouvez simplement étendre ShipMonkPHPStanDeadCodeProviderReflectionBasedMemberUsageProvider :

 use ReflectionMethod ;
use ShipMonk  PHPStan  DeadCode  Provider  ReflectionBasedMemberUsageProvider ;

class ApiOutputUsageProvider extends ReflectionBasedMemberUsageProvider
{

    public function shouldMarkMethodAsUsed ( ReflectionMethod $ method ): bool
    {
        // all methods from our ApiOutput interface are called automatically (e.g. during serialization)
        return $ method -> getDeclaringClass ()-> implementsInterface (ApiOutput::class);
    }

}

Personnalisation basée sur l'AST:

• Pour des utilisations plus complexes qui sont déductibles uniquement à partir de l'AST (par exemple, les appels de sérialisation), vous vous en tenez simplement à l'interface RAW MemberUsageProvider :

 use ReflectionMethod ;
use ShipMonk  PHPStan  DeadCode  Graph  ClassMethodRef ;
use ShipMonk  PHPStan  DeadCode  Graph  ClassMethodUsage ;
use ShipMonk  PHPStan  DeadCode  Provider  MemberUsageProvider ;
use Symfony  Component  Serializer  SerializerInterface ;

class DeserializationUsageProvider implements MemberUsageProvider
{

    /**
     * @return list<ClassMemberUsage>
     */
    public function getUsages ( Node $ node , Scope $ scope ): array
    {
        if (! $ node instanceof MethodCall) {
            return [];
        }

        if (
            // our deserialization calls constructor
            $ scope -> getType ( $ node -> var )-> getObjectClassNames () === [SerializerInterface::class] &&
            $ node -> name -> toString () === ' deserialize '
        ) {
            $ secondArgument = $ node -> getArgs ()[ 1 ]-> value ;
            $ serializedClass = $ scope -> getType ( $ secondArgument )-> getConstantStrings ()[ 0 ];

            // record the method it was called from (needed for proper transitive dead code elimination)
            $ originRef = $ this -> getOriginMethodRef ( $ scope );

            // record the hidden constructor call
            $ constructorRef = new ClassMethodRef ( $ serializedClass -> getValue (), ' __construct ' , false );

            return [ new ClassMethodUsage ( $ originRef , $ constructorRef )];
        }

        return [];
    }

    private function getOriginMethodRef ( Scope $ scope ): ? ClassMethodRef
    {
        return new ClassMethodRef (
            $ scope -> getClassReflection ()-> getName (),
            $ scope -> getFunction ()-> getName (),
            false ,
        );
    }

}

Cycles morts et méthodes transitoires mortes

• Cette bibliothèque détecte automatiquement les cycles morts et les méthodes mortes transitoires (méthodes qui ne sont appelées que des méthodes mortes)
• Par défaut, il ne rapporte que la première méthode morte dans le sous-arbre et le reste en tant que pointe:

 ------ ------------------------------------------------------------------------
  Line   src/App/Facade/UserFacade.php
 ------ ------------------------------------------------------------------------
  26     Unused AppFacadeUserFacade::updateUserAddress
         ?  shipmonk.deadMethod
          Thus AppEntityUser::updateAddress is transitively also unused
          Thus AppEntityAddress::setPostalCode is transitively also unused
          Thus AppEntityAddress::setCountry is transitively also unused
          Thus AppEntityAddress::setStreet is transitively also unused
          Thus AppEntityAddress::MAX_STREET_CHARS is transitively also unused
 ------ ------------------------------------------------------------------------

• Si vous souhaitez signaler toutes les méthodes mortes individuellement, vous pouvez l'activer dans votre phpstan.neon.dist :

 parameters :
    shipmonkDeadCode :
        reportTransitivelyDeadMethodAsSeparateError : true 

Suppression automatique du code mort

• Si vous êtes sûr que les méthodes signalées sont mortes, vous pouvez les supprimer automatiquement en exécutant PHPSTAN avec le format d'erreur removeDeadCode :

vendor/bin/phpstan analyse --error-format removeDeadCode

class UserFacade
{
-    public const TRANSITIVELY_DEAD = 1;
-
-    public function deadMethod(): void
-    {
-        echo self::TRANSITIVELY_DEAD;
-    }
}

Appels sur des types inconnus

• Afin d'éviter les faux positifs, nous soutenons même les appels sur des types inconnus (par exemple $unknown->method() ) en marquant toutes les méthodes nommées method comme utilisée
  • Un tel comportement peut ne pas être souhaité pour les bases de code strictement typées, car par exemple, un seul new $unknown() marquera tous les constructeurs comme utilisés
  • Ainsi, vous pouvez désactiver cette fonctionnalité dans votre phpstan.neon.dist :
• Il en va de même pour les récupérations constantes sur des types inconnus (par exemple $unknown::CONSTANT )

 parameters :
    shipmonkDeadCode :
        trackMixedAccess : false

• Si vous souhaitez vérifier combien de ces cas sont présents dans votre base de code, vous pouvez exécuter l'analyse PHPSTAN avec -vvv et vous verrez des diagnostics:

 Found 2 usages over unknown type:
 • setCountry method, for example in AppEntityUser::updateAddress
 • setStreet method, for example in AppEntityUser::updateAddress

Comparaison avec Tomasvotruba / non utilisée

• Vous pouvez voir une comparaison détaillée PR
• Fondamentalement, leur analyse est moins précise et moins flexible. Principalement:
  • Il ne peut pas détecter les constructeurs morts
  • Il ne détecte pas correctement les appels dans la hiérarchie des successions
  • Il n'offre aucun ajustement personnalisé des méthodes d'occasion
  • Il n'a presque pas d'extensions de bibliothèque intégrées
  • Il ignore les méthodes de traits
  • Est absent de nombreuses fonctionnalités mineures comme les appels à cordes de classe, les appels de méthode dynamique, les rappels de tableau, les chaînes d'appels nullsafe, etc.
  • Il ne peut pas détecter les cycles morts ni les méthodes transitoires mortes
  • Il n'a pas de suppression de code mort intégré

Limites:

• Les méthodes de classes anonymes ne sont jamais signalées comme mortes (limitation phpstan)
• Les méthodes de traits abstraites ne sont jamais signalées comme mortes
• La plupart des méthodes magiques (par exemple __get , __set , etc.) ne sont jamais signalées comme mortes
  • Seules sont pris en charge: __construct , __clone

Autres cas problématiques:

Constructeurs:

• Pour les applications Symfony et les extensions PHPSTAN, nous simplifions la détection en supposant que toutes les classes DIC ont utilisé le constructeur.
• Pour d'autres applications, vous pouvez obtenir des faux positifs si les services sont créés par magie.
  • Pour les éviter, vous pouvez facilement désactiver l'analyse du constructeur avec une seule ignoration:

 parameters :
    ignoreErrors :
        - ' # ^Unused .*?::__construct$ # ' 

Constructeurs privés:

• Ceux-ci ne sont jamais signalés aussi morts car ceux-ci sont souvent utilisés pour nier l'instanciation en classe

Méthodes d'interface:

• Si vous n'appelez jamais la méthode d'interface sur l'interface, mais seulement sur ses implémentors, il est signalé comme mort
• Mais vous voudrez peut-être garder la méthode d'interface pour forcer une certaine unification entre les implémentors
  • La façon la plus simple de l'ignorer est via Custom MemberUsageProvider :

 use ShipMonk  PHPStan  DeadCode  Provider  ReflectionBasedMemberUsageProvider ;

class IgnoreDeadInterfaceUsageProvider extends ReflectionBasedMemberUsageProvider
{
    public function shouldMarkMethodAsUsed ( ReflectionMethod $ method ): bool
    {
        return $ method -> getDeclaringClass ()-> isInterface ();
    }
}

Portée future:

• Détection de propriétés de la classe morte
• Détection de classe morte

Contributif

• Vérifiez votre code par composer check
• composer fix:cs
• Toutes les fonctionnalités doivent être testées

Versions PHP prises en charge

• PHP 7,4 - 8.4