Blog / Article #217
Psalm 7 et Symfony : L'analyse statique qui met vos bugs au tapis avant même de compiler

star

20 Novembre 2026
Illustration technique : A digital illustration of a shield with a PHP elephant logo, protecting a Symfony application code from various bugs and security vulnerabilities represented as small, stylized monsters. The scene is set in a clean, modern development environment with lines of code flowing in the background. Tech illustration style, no text on the image.

La joie de pousser du code en production, et de découvrir une erreur de type bien planquée ou, pire, une faille de sécurité insidieuse. Ça sent le vécu, pas vrai ? En tant que développeur backend, je sais que le temps, c'est de l'argent, et que chaque bug qui passe le filet coûte cher. C'est là que l'analyse statique entre en jeu, non pas comme un luxe, mais comme une nécessité absolue dans nos workflows PHP modernes.

Depuis quelques années, des outils comme Psalm ou PHPStan ont transformé notre manière de coder. Ils parcourent votre code sans l'exécuter, identifiant les problèmes avant même que votre application ne voie la lumière du jour. Et récemment, je suis tombé sur l'actualité de Psalm 7, la dernière version majeure de la « PHP Static Analysis Linting Machine ». Une mise à jour qui promet de rendre nos applications Symfony encore plus robustes et sécurisées. Accrochez-vous, on va décortiquer ça ensemble.

Pourquoi l'analyse statique est votre meilleur ami (et pourquoi Psalm 7 est un cran au-dessus)

L'analyse statique, c'est un peu votre relecteur de code infatigable et ultra-rigoureux. Il repère les erreurs de type, les variables non initialisées, le code mort, et bien d'autres aberrations que l'œil humain ou même les tests unitaires pourraient laisser passer. Dans un monde où PHP 8.2 et ses types stricts sont la norme, avoir un outil qui valide la cohérence de vos types est juste… vital.

Psalm, développé à l'origine par Matt Brown chez Vimeo et maintenant activement maintenu par Daniil Gentili et son équipe, a toujours eu une approche très axée sur la performance et la détection fine. Ce qui le distingue vraiment, surtout avec cette version 7, c'est son analyse de taint native. Contrairement à son cousin PHPStan, Psalm est capable de tracer le flux de données non fiables (les « taints ») depuis leur source (une entrée utilisateur, par exemple) jusqu'à un point sensible (une requête SQL, un appel à eval(), une sortie HTML). Ça, mes amis, c'est un bouclier anti-injections SQL, XSS et injections de commandes qui s'active avant même que vous ne déployiez.

Psalm 7, qui nécessite PHP >= 8.2 pour fonctionner, apporte des améliorations de performance significatives et une meilleure intégration avec les nouvelles fonctionnalités de PHP. C'est un pas de géant pour la qualité et la sécurité du code PHP.

Installation et configuration
Mettre Psalm 7 au boulot dans un projet Symfony

Passons aux choses sérieuses. Intégrer Psalm dans un projet Symfony existant est un jeu d'enfant avec Composer.

Étape 1 : Installation de Psalm

La première chose à faire est d'ajouter Psalm comme dépendance de développement :

composer require --dev vimeo/psalm

Si vous préférez la performance maximale ou une isolation parfaite, l'image Docker officielle est une excellente option. Elle utilise une version de PHP compilée sur mesure, jusqu'à 30% plus rapide !

docker run -v $PWD:/app --rm -it ghcr.io/psalm/psalm:latest /composer/vendor/bin/psalm --no-cache

Étape 2 : Initialisation de la configuration

Une fois installé, générez le fichier de configuration de base psalm.xml. C'est votre quartier général pour Psalm.

vendor/bin/psalm --init

Ce fichier ressemblera à ceci :

<?xml version="1.0"?>
<psalm errorLevel="6">
    <projectFiles>
        <directory name="src" />
        <ignoreFiles>
            <directory name="vendor" />
        </ignoreFiles>
    </projectFiles>
</psalm>

Le errorLevel est crucial. Il va de 1 (le plus strict) à 8 (le plus permissif). Pour un projet existant, je vous conseille de commencer avec un niveau 5 ou 6, et de l'augmenter progressivement au fur et à mesure que vous corrigez les problèmes. Le niveau par défaut est 2, ce qui peut être un peu brutal pour un projet legacy.

Étape 3 : Intégration avec Symfony

Pour que Psalm comprenne la magie de Symfony (services, conteneur de dépendances, entités Doctrine), il faut un plugin.

composer require --dev psalm/plugin-symfony

Ensuite, ajoutez ce plugin à votre psalm.xml :

<?xml version="1.0"?>
<psalm errorLevel="6">
    <projectFiles>
        <directory name="src" />
        <ignoreFiles>
            <directory name="vendor" />
        </ignoreFiles>
    </projectFiles>
    <plugins>
        <pluginClass class="Psalm\SymfonyPsalmPlugin\Plugin">
            <!-- Important : le chemin vers le conteneur compilé de Symfony -->
            <containerXml>var/cache/dev/App_KernelDevDebugContainer.xml</containerXml>
        </pluginClass>
    </plugins>
</psalm>

Le chemin vers le containerXml est vital. Il indique à Psalm où trouver la définition de vos services Symfony. Ce chemin peut varier légèrement selon votre version de Symfony (pour Symfony 5+, c'est généralement var/cache/dev/App_KernelDevDebugContainer.xml). Sans ça, Psalm ne pourra pas analyser correctement les types de vos services injectés.

Analyse et détection de problèmes : Exemples concrets

Maintenant que Psalm est configuré, voyons-le à l'œuvre.

Exécuter une analyse de base

Pour lancer une analyse complète, tapez simplement :

vendor/bin/psalm

Psalm va alors scanner votre code et vous remonter tous les problèmes détectés selon le errorLevel défini.

Détection d'erreurs de type

Imaginez ce code un peu bancal :

<?php

namespace App\Service;

class Calculator
{
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
}

class UserService
{
    private Calculator $calculator;

    public function __construct(Calculator $calculator)
    {
        $this->calculator = $calculator;
    }

    public function processUserOperation(string $value1, string $value2): int
    {
        // On passe des strings à une méthode qui attend des ints
        return $this->calculator->add($value1, $value2);
    }
}

Psalm va immédiatement vous alerter sur processUserOperation, car vous tentez de passer des string à une méthode qui attend des int. Un classique, mais que l'on peut rater sans une bonne analyse statique.

Analyse de Taint (Sécurité)

C'est là que Psalm brille particulièrement. Pour activer l'analyse de sécurité :

vendor/bin/psalm --taint-analysis

Prenons un exemple de code vulnérable à une injection XSS :

<?php

namespace App\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class SecurityController
{
    #[Route('/greet', name: 'app_greet')]
    public function greet(Request $request): Response
    {
        $name = $request->query->get('name'); // Source de taint
        // Pas d'échappement !
        return new Response('<h1>Bonjour, ' . $name . '!</h1>'); // Point sensible (sink)
    }
}

Psalm, avec l'analyse de taint, tracerait la variable $name depuis l'entrée utilisateur (une source de taint) jusqu'à son injection directe dans la réponse HTML (un « sink » ou point sensible) sans échappement. Il vous signalerait une vulnérabilité XSS potentielle, ce que peu d'outils d'analyse statique font nativement.

Aller plus loin : Baselines, Plugins et CI/CD

Pour une intégration plus poussée, Psalm offre plusieurs fonctionnalités.

Gérer les projets legacy avec les baselines

Si vous intégrez Psalm dans un gros projet existant, il risque de vous inonder d'erreurs. Pas de panique ! Créez une « baseline » :

vendor/bin/psalm --set-baseline=psalm-baseline.xml

Ce fichier psalm-baseline.xml va enregistrer toutes les erreurs actuelles. Psalm les ignorera lors des prochaines analyses, vous permettant de vous concentrer sur les nouveaux problèmes introduits. C'est une excellente stratégie pour l'adoption progressive.

Plugins et extensions

L'écosystème de plugins de Psalm est en constante évolution. Outre le plugin Symfony, il existe des plugins pour Doctrine, Twig, Laravel (si jamais vous vous égarez un jour 😉), et bien d'autres. Ils améliorent la compréhension de Psalm pour des frameworks ou librairies spécifiques.

Intégration en CI/CD

Pour un workflow de développement optimal, intégrez Psalm à votre pipeline de CI/CD. Avant chaque fusion de branche ou déploiement, lancez Psalm. Si l'analyse échoue (car de nouvelles erreurs ont été introduites), la pipeline s'arrête. C'est la garantie que seul du code de qualité passe en production.

Un simple script dans votre .gitlab-ci.yml ou .github/workflows/main.yml suffit :

# Exemple pour GitHub Actions
name: PHP Lint & Test

on: [push, pull_request]

jobs:
  psalm:
    name: Run Psalm Static Analysis
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
          extensions: mbstring, xml, pdo_mysql
# Adaptez les extensions nécessaires
          coverage: none

      - name: Install Composer dependencies
        run: composer install --no-interaction --prefer-dist --optimize-autoloader

      - name: Run Psalm
        run: vendor/bin/psalm --taint-analysis
# Ou juste 'vendor/bin/psalm' si vous ne voulez pas l'analyse de taint

Psalm vs PHPStan : Faut-il choisir ?

La question revient souvent. PHPStan et Psalm sont tous deux d'excellents outils. La force de Psalm réside dans son analyse de taint native et ses performances souvent supérieures, notamment via l'image Docker optimisée. PHPStan, lui, a un écosystème de plugins plus vaste et une communauté très active. Beaucoup d'équipes choisissent d'utiliser les deux, car ils ne détectent pas exactement les mêmes types de problèmes et peuvent être complémentaires. Si la sécurité est votre priorité, Psalm est un choix évident pour sa capacité à traquer les vulnérabilités.

Le mot de la fin

Psalm 7 est bien plus qu'une simple mise à jour. C'est un outil mature et puissant qui, avec son analyse de taint intégrée, vous donne une longueur d'avance sur les bugs et les failles de sécurité. L'intégrer dans votre workflow de développement Symfony, c'est adopter une approche proactive de la qualité du code. Non seulement il vous aidera à écrire du code plus robuste et maintenable, mais il renforcera également la sécurité de vos applications.

Alors, n'hésitez plus. Prenez quelques heures pour l'installer, le configurer et le laisser scanner votre base de code. Vous serez probablement surpris de ce qu'il va débusquer. Votre moi futur (et vos utilisateurs) vous remerciera.

Publié le 20/11/2026 · 8 min de lecture Partager X LinkedIn

← Précédent Cli-anything : quand vos clis passent de muettes à polyglottes pour les agents ia