Rector : automatiser 80 % de votre refactoring PHP

Refactorer manuellement un projet PHP de 500 fichiers pour passer de PHP 7.4 à 8.3, c’est des semaines de travail répétitif et risqué. Rector fait ce travail en quelques minutes, de manière déterministe et sans régression. C’est l’outil de refactoring PHP le plus puissant de l’écosystème, et tu devrais l’intégrer dans ta toolbox immédiatement.

Comment Rector fonctionne

Rector analyse ton code via l’AST (Abstract Syntax Tree) — une représentation structurée de ton code PHP. Contrairement à des regex ou des find-and-replace, Rector comprend la structure du code : il distingue un nom de variable d’un nom de classe, un type de retour d’un type de paramètre. Chaque transformation est une « règle » qui modifie l’AST de manière précise et sûre.

Le processus : Rector lit ton fichier PHP → le parse en AST → applique les règles sélectionnées → génère le nouveau code. C’est déterministe : la même entrée produit toujours la même sortie.

Cas d’usage #1 : Upgrade PHP

Le cas d’usage le plus courant. Tu passes de PHP 7.4 à 8.3 ? Rector transforme automatiquement les typed properties, ajoute les union types, remplace les annotations par des attributes, et modernise les patterns obsolètes.

<?php
// AVANT (PHP 7.4)
class UserService
{
    /** @var EntityManagerInterface */
    private $em;

    /** @var LoggerInterface */
    private $logger;

    public function __construct(
        EntityManagerInterface $em,
        LoggerInterface $logger
    ) {
        $this->em = $em;
        $this->logger = $logger;
    }
}

// APRÈS (PHP 8.3 — transformé par Rector)
final readonly class UserService
{
    public function __construct(
        private EntityManagerInterface $em,
        private LoggerInterface $logger,
    ) {}
}

Cas d’usage #2 : Migration Symfony

Rector dispose de rule sets dédiés à Symfony qui gèrent les transformations de version en version : annotations vers attributes, méthodes dépréciées remplacées, injections modernisées.

<?php
// AVANT (Symfony 5.x)
/**
 * @Route("/users", name="user_list")
 * @Method("GET")
 */
public function list(): Response
{
    $em = $this->getDoctrine()->getManager();
}

// APRÈS (Symfony 7.x — transformé par Rector)
#[Route('/users', name: 'user_list', methods: ['GET'])]
public function list(): Response
{
    // getDoctrine() remplacé par injection constructeur
}

Cas d’usage #3 : Règles de qualité

Au-delà des migrations, Rector propose des règles de qualité générales :

• Dead code removal — Supprime le code mort (méthodes non appelées, variables inutilisées)
• Type declarations — Ajoute les types manquants déduits du code
• Early return — Transforme les conditions imbriquées en early returns
• Privatization — Rend privé ce qui peut l’être

Configuration rector.php

Voici une configuration type pour un projet Symfony :

<?php
// rector.php
use Rector\Config\RectorConfig;
use Rector\Set\ValueObject\LevelSetList;
use Rector\Set\ValueObject\SetList;
use Rector\Symfony\Set\SymfonySetList;

return RectorConfig::configure()
    ->withPaths([
        __DIR__ . '/src',
        __DIR__ . '/tests',
    ])
    ->withSets([
        LevelSetList::UP_TO_PHP_83,

        SetList::CODE_QUALITY,
        SetList::DEAD_CODE,
        SetList::EARLY_RETURN,
        SetList::TYPE_DECLARATION,

        SymfonySetList::SYMFONY_64,
        SymfonySetList::SYMFONY_CODE_QUALITY,
        SymfonySetList::SYMFONY_CONSTRUCTOR_INJECTION,
    ])
    ->withImportNames();

Intégration CI/CD

Rector s’intègre parfaitement dans ta pipeline CI. Le mode --dry-run vérifie que le code est à jour sans rien modifier :

# Vérifier que Rector n’a rien à transformer (CI)
vendor/bin/rector process --dry-run

# Appliquer les transformations (dev)
vendor/bin/rector process

# Analyser un seul fichier
vendor/bin/rector process src/Service/UserService.php --dry-run

Si --dry-run retourne des différences, la CI échoue. Cela garantit que le code commité respecte toujours les règles Rector configurées.

Rector + Claude Code : le duo gagnant

La combinaison la plus efficace pour moderniser un projet PHP ? Rector gère les transformations déterministes (90 % du travail) : annotations vers attributes, méthodes dépréciées, modernisation syntaxique. Claude Code gère les 10 % restants qui nécessitent de la compréhension contextuelle : logique métier impactée, cas particuliers, tests à adapter.

C’est exactement cette approche que Bear Upgrade utilise pour automatiser les migrations Symfony : Rector pour les transformations mécaniques, Claude Code pour l’adaptation intelligente, et une validation complète (PHPStan + PHPUnit) à chaque étape. Le résultat : une migration plus rapide, plus sûre, et à un coût prévisible.