Descarga dead code detector - Descarga del código fuente dead code detector

dead code detector

Otras categorias

0.7.0

Descargar

Detector de código muerto para PHP

¡Extensión PHPSTAN para encontrar el código PHP no utilizado en su proyecto con facilidad!

Resumen:

✅ Extensión de Phpstan
♻️ Detección de ciclos muertos
? Detección de miembros muertos transitivos
? Eliminación automática del código no utilizado
Soporte de bibliotecas populares
Proveedores de uso personalizables

Instalación:

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

Use el instalador de extensión oficial o simplemente cargue las reglas:

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

Bibliotecas compatibles:

Symfony:

¡Llamadas realizadas por DIC sobre sus servicios!
- constructores, llamadas, métodos de fábrica
- se debe usar phpstan/phpstan-symfony con containerXmlPath
#[AsEventListener]
#[AsController]
#[AsCommand]
#[Required] atributo
#[Route] atributos
EventSubscriberInterface::getSubscribedEvents
onKernelResponse , onKernelRequest , etc.

Doctrina:

#[AsEntityListener]
DoctrineORMEvents::* eventos
DoctrineCommonEventSubscriber Métodos
Atributos del evento de ciclo de vida #[PreFlush] , #[PostLoad] , ...

Phpunit:

Métodos del proveedor de datos
métodos testXxx
Anotaciones como @test , @before , @afterClass , etc.
atributos como #[Test] , #[Before] , #[AfterClass] etc.

Phpstan:

Llamadas de constructor para servicios DIC (reglas, extensiones, ...)

Nette:

handleXxx , renderXxx , actionXxx , injectXxx , createComponentXxx
SmartObject Magic llama a @property Annotations

Todas esas bibliotecas se encuentran automáticamente cuando se encuentran dentro de sus dependencias de compositor. Si desea forzar/deshabilitar algunos de ellos, puede:

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

Proveedores de uso genérico:

Reflexión:

Cualquier constante o método accedido a través de ReflectionClass se detecta como se usa
- por ejemplo, $reflection->getConstructor() , $reflection->getConstant('NAME') , $reflection->getMethods() , ...

Proveedor:

Cualquier método anulado que se origine en vendor no se informa como muerto
- por ejemplo, implementación PsrLogLoggerInterface::log se considera automáticamente utilizado

Esos proveedores están habilitados de forma predeterminada, pero puede deshabilitarlos si es necesario.

Personalización:

Si su aplicación hace algunas llamadas mágicas desconocidas para esta biblioteca, puede implementar su propio proveedor de uso.
Simplemente etiquételo con shipmonk.deadCode.memberUsageProvider e implementa ShipMonkPHPStanDeadCodeProviderMemberUsageProvider

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

Importante

La interfaz y la etiqueta cambiaron en 0.7. Si está utilizando phpstan 1.x, se usaron de manera diferente.

Personalización basada en la reflexión:

Para Usecases de reflexión simple, solo puede extender 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);
    }

}

Personalización basada en AST:

Para los casos de uso más complejos que son deducibles solo de AST (por ejemplo, llamadas de serialización), simplemente se queda con la interfaz 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 muertos y métodos transitivamente muertos

Esta biblioteca detecta automáticamente los ciclos muertos y los métodos de forma transitiva (métodos que solo se llaman a partir de métodos muertos)
Por defecto, informa solo el primer método muerto en el subárbol y el resto como consejo:

 ------ ------------------------------------------------------------------------
  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 desea informar todos los métodos muertos individualmente, puede habilitarlo en su phpstan.neon.dist :

 parameters :
    shipmonkDeadCode :
        reportTransitivelyDeadMethodAsSeparateError : true

Eliminación automática del código muerto

Si está seguro de que los métodos informados están muertos, puede eliminarlos automáticamente ejecutando PHPSTAN con el formato de error de Code removeDeadCode :

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

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

Llamadas sobre tipos desconocidos

Para evitar falsos positivos, apoyamos incluso llamadas sobre tipos desconocidos (por ejemplo $unknown->method() ) marcando todos los métodos nombrados method como se usa
- Tal comportamiento es posible que no se desee para bases de código estrictamente escrita, porque por ejemplo, un solo new $unknown() marcará todos los constructores tal como se usan
- Por lo tanto, puede deshabilitar esta función en su phpstan.neon.dist :
Lo mismo se aplica a las ganancias constantes sobre tipos desconocidos (por ejemplo, $unknown::CONSTANT )

 parameters :
    shipmonkDeadCode :
        trackMixedAccess : false

Si desea verificar cuántos de esos casos están presentes en su base de código, puede ejecutar el análisis PHPSTAN con -vvv y verá algunos diagnósticos:

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

Comparación con Tomasvotruba/no utilizado público

Puedes ver la comparación detallada PR
Básicamente, su análisis es menos preciso y menos flexible. Principalmente:
- No puede detectar constructores muertos
- No detecta correctamente las llamadas dentro de la jerarquía de herencia
- No ofrece ningún ajuste personalizado de métodos usados
- Casi no tiene extensiones de biblioteca incorporadas
- Ignora los métodos de rasgos
- Carece de muchas características menores como llamadas de cadena de clase, llamadas de método dinámico, devoluciones de llamada de matriz, cadenas de llamadas nullsafe, etc.
- No puede detectar ciclos muertos ni métodos transsitivamente muertos
- No tiene eliminación de código muerto incorporado

Limitaciones:

Los métodos de clases anónimas nunca se informan como muertos (limitación de Phpstan)
Los métodos de rasgos abstractos nunca se informan como muertos
La mayoría de los métodos mágicos (por ejemplo, __get , __set , etc.) nunca se informan como muertos
- Solo admitidos son: __construct , __clone

Otros casos problemáticos:

Constructores:

Para Symfony Apps & Phpstan Extensions, simplificamos la detección asumiendo que todas las clases de DIC han utilizado el constructor.
Para otras aplicaciones, puede obtener falsos positivos si los servicios se crean mágicamente.
- Para evitarlos, puede deshabilitar fácilmente el análisis de constructor con un solo ignorado:

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

Constructores privados:

Esos nunca se informan tan muertos como se usan a menudo para negar la instanciación de la clase

Métodos de interfaz:

Si nunca llama al método de interfaz de la interfaz, pero solo a través de sus implementadores, se informa como muerto
Pero es posible que desee mantener el método de interfaz para forzar alguna unificación entre los implementadores
- La forma más fácil de ignorarlo es a través de MemberUsageProvider personalizado:

 use ShipMonk  PHPStan  DeadCode  Provider  ReflectionBasedMemberUsageProvider ;

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