Download dead code detector - Download do código fonte dead code detector

dead code detector

Outras categorias

0.7.0

Baixar

Detector de código morto para PHP

Extensão do Phpstan para encontrar código PHP não utilizado em seu projeto com facilidade!

Resumo:

✅ Extensão do Phpstan
♻️ Detecção de ciclos mortos
? Detecção de Membro Dead Transitivo
? Remoção automática de código não utilizado
Suporte de bibliotecas populares
Provedores de uso personalizáveis

Instalação:

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

Use o Instalador de Extensão Oficial ou apenas carregue as regras:

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

Bibliotecas suportadas:

Symfony:

Chamadas feitas pela DIC sobre seus serviços!
- construtores, chamadas, métodos de fábrica
- phpstan/phpstan-symfony com containerXmlPath deve ser usado
#[AsEventListener] Atributo
#[AsController] atributo
#[AsCommand] atributo
#[Required] atributo
#[Route] atributos
EventSubscriberInterface::getSubscribedEvents
onKernelResponse , onKernelRequest , etc

Doutrina:

#[AsEntityListener] Atributo
DoctrineORMEvents::* eventos
DoctrineCommonEventSubscriber Methods
Atributos do evento do ciclo de vida #[PreFlush] , #[PostLoad] , ...

Phpunit:

Métodos do provedor de dados
Métodos testXxx
anotações como @test , @before , @afterClass etc
Atributos como #[Test] , #[Before] , #[AfterClass] etc.

Phpstan:

Construtor exige serviços DIC (regras, extensões, ...)

Nette:

handleXxx , renderXxx , actionXxx , injectXxx , createComponentXxx
SmartObject Magic exige @property Anotações

Todas essas bibliotecas são autoeenabilitadas quando encontradas nas dependências do compositor. Se você deseja forçar ativar/desativar alguns deles, você pode:

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

Provedores de uso genérico:

Reflexão:

Qualquer constante ou método acessado via ReflectionClass é detectado como usado
- por exemplo, $reflection->getConstructor() , $reflection->getConstant('NAME') , $reflection->getMethods() , ...

Fornecedor:

Qualquer método substituído que se origina no vendor não é relatado como morto
- Por exemplo, implementando PsrLogLoggerInterface::log é considerado automaticamente usado

Esses provedores são ativados por padrão, mas você pode desativá -los, se necessário.

Personalização:

Se o seu aplicativo fizer algumas chamadas mágicas desconhecidas para esta biblioteca, você poderá implementar seu próprio provedor de uso.
Basta marcar com shipmonk.deadCode.memberUsageProvider e implementar ShipMonkPHPStanDeadCodeProviderMemberUsageProvider

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

Importante

A interface e a tag mudou em 0.7. Se você estiver usando o phpstan 1.x, eles foram usados de maneira diferente.

Personalização baseada em reflexão:

Para usugas simples de reflexão, você pode apenas estender 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);
    }

}

Personalização baseada em AST:

Para redes mais complexas que são dedutíveis apenas de AST (por exemplo, chamadas de serialização), basta ficar com a 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 ,
        );
    }

}

Ciclos mortos e métodos transminantes mortos

Esta biblioteca detecta automaticamente os ciclos mortos e os métodos mortos de transmissão (métodos que são chamados apenas dos métodos mortos)
Por padrão, ele relata apenas o primeiro método morto na subárvore e o restante como uma dica:

 ------ ------------------------------------------------------------------------
  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
 ------ ------------------------------------------------------------------------

Se você deseja relatar todos os métodos mortos individualmente, pode ativá -lo em seu phpstan.neon.dist :

 parameters :
    shipmonkDeadCode :
        reportTransitivelyDeadMethodAsSeparateError : true

Remoção automática do código morto

Se você tem certeza de que os métodos relatados estão mortos, você pode removê -los automaticamente executando o Phpstan com o formato de erro removeDeadCode :

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

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

Chamadas sobre tipos desconhecidos

Para evitar falsos positivos, apoiamos mesmo chamadas sobre tipos desconhecidos (por exemplo $unknown->method() ) marcando todos os métodos nomeados como method usado
- Esse comportamento pode não ser desejado para bases de código estritamente digitadas, porque, por exemplo new $unknown() marcará todos os construtores conforme usado
- Assim, você pode desativar esse recurso em seu phpstan.neon.dist :
O mesmo se aplica a buscas constantes sobre tipos desconhecidos (por exemplo, $unknown::CONSTANT )

 parameters :
    shipmonkDeadCode :
        trackMixedAccess : false

Se você deseja verificar quantos desses casos estão presentes na sua base de código, você pode executar a análise do Phpstan com -vvv e verá alguns diagnósticos:

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

Comparação com Tomasvotruba/não utilizado

Você pode ver comparação detalhada pr
Basicamente, sua análise é menos precisa e menos flexível. Principalmente:
- Não pode detectar construtores mortos
- Não detecta corretamente chamadas dentro da hierarquia de herança
- Não oferece nenhum ajuste personalizado de métodos usados
- Quase não tem extensões de biblioteca embutidas
- Ignora métodos de característica
- Não tem muitos recursos menores, como chamadas de linha de classe, chamadas de método dinâmico, retornos de chamada de matriz, correntes de chamadas NullSafe etc.
- Não pode detectar ciclos mortos nem métodos transitivos mortos
- Não tem remoção de código morto embutido

Limitações:

Métodos de aulas anônimas nunca são relatadas como mortas (limitação do Phpstan)
Os métodos de características abstratos nunca são relatados como mortos
A maioria dos métodos mágicos (por exemplo __get , __set etc) nunca são relatados como mortos
- Somente suportados são: __construct , __clone

Outros casos problemáticos:

Construtores:

Para aplicativos Symfony e extensões de Phpstan, simplificamos a detecção assumindo que todas as classes DIC usaram o construtor.
Para outros aplicativos, você pode obter falsos positivos se os serviços forem criados magicamente.
- Para evitá -los, você pode desativar facilmente a análise do construtor com um único ignorado:

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

Construtores privados:

Aqueles nunca são relatados tão mortos, pois são frequentemente usados para negar a instanciação da classe

Métodos de interface:

Se você nunca chama o método da interface sobre a interface, mas apenas sobre seus implementadores, ele será relatado como morto
Mas você pode querer manter o método da interface para forçar alguma unificação entre os implementadores
- A maneira mais fácil de ignorá -lo é via MemberUsageProvider personalizado:

 use ShipMonk  PHPStan  DeadCode  Provider  ReflectionBasedMemberUsageProvider ;

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