Coder sans filet, vraiment ?

Pourquoi l’analyse statique change vraiment la donne

Détection précoce des bugs

• Les erreurs de types (TypeError latents)
• Les accès à des propriétés ou méthodes inexistantes
• Les variables non initialisées
• Les code paths jamais atteints
• Les retours de fonction incompatibles avec leur signature

Documentation vivante du code

Refactoring en confiance

Uniformisation du code

Automatisation naturelle

Les outils de l’arsenal

PHP CS Fixer — le gardien du style

Installation

composer require --dev friendsofphp/php-cs-fixer

Configuration (.php-cs-fixer.php)

$finder = PhpCsFixer\Finder::create()
    ->in([__DIR__ . '/src', __DIR__ . '/tests'])
    ->exclude(['var', 'vendor']);

return (new PhpCsFixer\Config())
    ->setRules([
        '@PER-CS' => true,
        '@Symfony' => true,
        '@autoPHPMigration' => true,
        'array_syntax' => ['syntax' => 'short'],
        'ordered_imports' => ['sort_algorithm' => 'alpha'],
        'no_unused_imports' => true,
        'strict_comparison' => true,
    ])
    ->setFinder($finder);

Utilisation

# Vérifier sans corriger (pour la CI)
vendor/bin/php-cs-fixer fix --dry-run --diff

# Corriger
vendor/bin/php-cs-fixer fix

Ce que CS Fixer normalise

• Indentation, espaces, sauts de ligne
• Ordre et groupement des use
• Déclarations strict_types
• Casts, opérateurs, virgules trailing
• PHPDoc et annotations

PHPStan — l’analyse statique de référence

Installation

composer require --dev phpstan/phpstan
composer require --dev phpstan/extension-installer
composer require --dev phpstan/phpstan-symfony
composer require --dev phpstan/phpstan-doctrine

Configuration (phpstan.neon)

parameters:
    level: 6
    paths:
        - src
        - tests
    symfony:
        containerXmlPath: var/cache/dev/App_KernelDevDebugContainer.xml
    ignoreErrors:
        - '#Call to an undefined method Doctrine\\ORM\\QueryBuilder#'

Les niveaux de rigueur (0 à 10)

Ce que PHPStan détecte

// PHPStan niveau 5+ détecte ce problème
class UserService
{
    public function findUser(int $id): User
    {
        return $this->repository->find($id); // ⚠️ retourne User|null, pas User !
    }
}

------ -----------------------------------------------
 Line   src/Service/UserService.php
------ -----------------------------------------------
 8      Method UserService::findUser() should return
        App\Entity\User but returns App\Entity\User|null.
------ ----------------------------------------------

Baseline : apprivoiser un projet legacy

vendor/bin/phpstan analyse --generate-baseline

includes:
	- phpstan-baseline.neon

Rector — bien plus qu’un outil de migration

Installation

composer require --dev rector/rector
composer require --dev tomasvotruba/type-coverage

Rector comme outil de réduction de dette — sans migration

use Rector\Config\RectorConfig;
use Rector\Set\ValueObject\SetList;

return RectorConfig::configure()
    ->withPaths([__DIR__ . '/src', __DIR__ . '/tests'])
    ->withSets([
        SetList::DEAD_CODE,       // supprime le code mort
        SetList::CODE_QUALITY,    // simplifie les constructions inutilement complexes
        SetList::CODING_STYLE,    // uniformise les idiomes PHP
        SetList::TYPE_DECLARATION, // ajoute les types manquants là où ils sont inférables
    ]);

// Avant — condition toujours vraie, branche morte
if ($user instanceof User) {
    return $user->getName(); // $user est déjà typé User
}

// Après
return $user->getName();

// Avant — construction inutilement verbeuse
$result = [];
foreach ($items as $item) {
    $result[] = $item->getValue();
}
return $result;

// Après
return array_map(fn($item) => $item->getValue(), $items);

// Avant — types absents dans une classe dont Rector peut les inférer
class OrderService
{
    private $repository;

    public function __construct(OrderRepository $repository)
    {
        $this->repository = $repository;
    }

    public function find($id)
    {
        return $this->repository->find($id);
    }
}

// Après — types ajoutés automatiquement
class OrderService
{
    public function __construct(
        private readonly OrderRepository $repository,
    ) {}

    public function find(int $id): ?Order
    {
        return $this->repository->find($id);
    }
}

// Avant
if ($user !== null) {
    return $user->getName();
}
return 'Anonymous';

// Après
return $user?->getName() ?? 'Anonymous';

Quand activer les sets de migration

->withSets([
    SymfonySetList::ANNOTATIONS_TO_ATTRIBUTES,
    DoctrineSetList::ANNOTATIONS_TO_ATTRIBUTES,
])

// Avant (annotations)
/**
 * @Route("/api/users", methods={"GET"})
 * @IsGranted("ROLE_USER")
 */
public function list(): JsonResponse { ... }

// Après (attributs PHP 8) — appliqué automatiquement
#[Route('/api/users', methods: ['GET'])]
#[IsGranted('ROLE_USER')]
public function list(): JsonResponse { ... }

Mode dry-run : toujours vérifier avant d’appliquer

# Aperçu des changements sans les appliquer
vendor/bin/rector process --dry-run

# Application réelle
vendor/bin/rector process

Levels : petit pas par petit pas

use Rector\Config\RectorConfig;

return RectorConfig::configure()
    ->withTypeCoverageLevel(0)
    ->withTypeCoverageDocblockLevel(0)
    ->withDeadCodeLevel(0)
    ->withCodeQualityLevel(0)
    ->withCodingStyleLevel(0);

Rector Swiss Knife — la boîte à outils complémentaire

Installation

composer require --dev rector/swiss-knife

Fonctionnalités clés

vendor/bin/swiss-knife check-conflicts .

vendor/bin/swiss-knife check-commented-code src tests

# Détecte les classes qui pourraient être déclarées final
vendor/bin/swiss-knife finalize-classes src

vendor/bin/swiss-knife find-multi-classes src

vendor/bin/swiss-knife namespace-to-psr-4 src --namespace-root "App\\"

Intégration dans un projet Symfony

Structure du projet

projet/
├── .php-cs-fixer.php
├── phpstan.neon
├── phpstan-baseline.neon
├── rector.php
└── composer.json

Utilisation avec Composer

{
    "scripts": {
        "cs-check": "php-cs-fixer fix --dry-run --diff",
        "cs-fix": "php-cs-fixer fix",
        "stan": "phpstan analyse",
        "rector-check": "rector process --dry-run",
        "rector-fix": "rector process",
        "psr4-fix": "swiss-knife namespace-to-psr-4 src --namespace-root \"App\\\\\"",
        "finalize-fix": "swiss-knife finalize-classes src tests",
        "swiss-check": [
            "swiss-knife check-conflicts .",
            "swiss-knife check-commented-code src tests",
            "swiss-knife find-multi-classes src"
        ],
        "qa": [
            "@cs-check",
            "@stan",
            "@rector-check",
            "@swiss-check"
        ],
        "fix": [
            "@cs-fix",
            "@rector-fix",
            "@psr4-fix",
            "@finalize-fix"
        ]
    }
}

Pipeline CI/CD (GitLab CI)

stages:
  - quality

variables:
  COMPOSER_CACHE_DIR: "$CI_PROJECT_DIR/.composer-cache"

cache:
  key: "${CI_COMMIT_REF_SLUG}"
  paths:
    - .composer-cache/
    - vendor/

image: php:8.2-cli

before_script:
  - apt-get update -yqq && apt-get install -yqq git unzip
  - curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
  - composer install --no-progress --no-interaction

cs-check:
  stage: quality
  script:
    - composer cs-check
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH'

phpstan:
  stage: quality
  script:
    - composer phpstan
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH'

rector:
  stage: quality
  script:
    - composer rector-check
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH'

swiss:
  stage: quality
  script:
    - composer swiss-check
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_BRANCH'

Par où commencer sur un projet existant ?

1. Style et formatage → Intégrez PHP CS Fixer avec les règles @Symfony. Appliquez-le une fois sur toute la base de code, commitez, et activez-le en CI.
2. Analyse statique niveau 0 → Ajoutez Rector en dry-run et mettez en place les nouvelles règles au niveau 0. → Ajoutez PHPStan niveau 0, générez une baseline. Zéro nouvelles erreurs autorisées dès maintenant.
3. Montée en niveau → Montez PHPStan niveau par niveau en corrigeant les erreurs de la baseline au fur et à mesure. Sur un projet existant le niveau 10 peut être trop exigeant, le niveau 6 est généralement suffisant. → Montez progressivement les niveaux des règles de Rector. Dès quelles sont atteintes, vous pourrez introduire de nouvelles règles.
4. Peaufiner le projet → Ajoutez Swiss-knife pour ajouter les dernières amélioration possibles.

Conclusion