PHP Parser

Analyseur PHP

Il s'agit d'un analyseur PHP écrit en PHP. Son objectif est de simplifier l’analyse et la manipulation du code statique.

Documentation pour la version 5.x (actuelle ; pour fonctionner sur PHP >= 7.4 ; pour analyser PHP 7.0 vers PHP 8.4, avec une prise en charge limitée pour l'analyse de PHP 5.x).

Documentation pour la version 4.x (prise en charge ; pour fonctionner sur PHP >= 7.0 ; pour analyser PHP 5.2 vers PHP 8.3).

Caractéristiques

Les principales fonctionnalités fournies par cette bibliothèque sont :

• Analyse du code PHP 7 et PHP 8 dans un arbre de syntaxe abstraite (AST).

• Un code invalide peut être analysé dans un AST partiel.

• L'AST contient des informations de localisation précises.

• Vider l'AST sous une forme lisible par l'homme.

• Reconversion d'un AST en code PHP.

• Le formatage peut être conservé pour les AST partiellement modifiés.

• Infrastructure pour parcourir et modifier les AST.

• Résolution des noms avec espace de noms.

• Évaluation d'expressions constantes.

• Les constructeurs simplifient la construction AST pour la génération de code.

• Conversion d'un AST en JSON et inversement.

Démarrage rapide

Installez la bibliothèque à l'aide de Composer :

php composer.phar require nikic/php-parser

Analysez du code PHP dans un AST et videz le résultat sous une forme lisible par l'homme :

 <?phpuse PhpParserError;use PhpParserNodeDumper;use PhpParserParserFactory;$code = <<<'CODE'<?phpfunction test($foo){ var_dump($foo);}CODE;$parser = (new ParserFactory())->createForNewestSupportedVersion ();essayez {$ast = $parser->parse($code);
} catch (Erreur $error) {echo "Erreur d'analyse : {$error->getMessage()}n";return;
}$dumper = new NodeDumper;echo $dumper->dump($ast) . "n" ;

Cela génère un AST ressemblant à ceci :

array(
    0: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: test
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: null
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: foo
                )
                default: null
            )
        )
        returnType: null
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_FuncCall(
                    name: Name(
                        name: var_dump
                    )
                    args: array(
                        0: Arg(
                            name: null
                            value: Expr_Variable(
                                name: foo
                            )
                            byRef: false
                            unpack: false
                        )
                    )
                )
            )
        )
    )
)

Parcourons l'AST et effectuons une sorte de modification. Par exemple, supprimez tous les corps de fonction :

 utiliser PhpParserNode;utiliser PhpParserNodeStmtFunction_;utiliser PhpParserNodeTraverser;utiliser PhpParserNodeVisitorAbstract;$traverser = new NodeTraverser();$traverser->addVisitor(la nouvelle classe étend NodeVisitorAbstract {public function enterNode(Node $node) {if ($node instanceof Function_) {// Nettoyer la fonction corps$node->stmts = [];
        }
    }
});$ast = $traverser->traverse($ast);echo $dumper->dump($ast) . "n" ;

Cela nous donne un AST où les Function_::$stmts sont vides :

array(
    0: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: test
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                type: null
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: foo
                )
                default: null
            )
        )
        returnType: null
        stmts: array(
        )
    )
)

Enfin, nous pouvons reconvertir le nouvel AST en code PHP :

 utilisez PhpParserPrettyPrinter;$prettyPrinter = new PrettyPrinterStandard;echo $prettyPrinter->prettyPrintFile($ast);

Cela nous donne notre code original, moins l'appel var_dump() à l'intérieur de la fonction :

 <?phpfonction test ($foo)
{
}

Pour une introduction plus complète, consultez la documentation.

Documentation

1. Introduction

2. Utilisation des composants de base

Documentation des composants :

• Marcher sur l'AST

• Visiteurs du nœud

• Modifier l'AST d'un visiteur

• Traversées en court-circuit

• Visiteurs entrelacés

• API de recherche de nœud simple

• Références des parents et des frères et sœurs

• Résolution de nom

• Options du résolveur de noms

• Contexte de résolution de noms

• Jolie impression

• Reconvertir AST en code PHP

• Personnalisation du formatage

• Transformations de code préservant le formatage

• Constructeurs AST

• Constructeurs fluides pour les nœuds AST

• Lexer

• Émulation

• Jetons, positions et attributs

• Gestion des erreurs

• Informations sur les colonnes pour les erreurs

• Récupération d'erreur (analyse de code syntaxiquement incorrect)

• Évaluation d'expression constante

• Évaluation des initialiseurs constant/propriété/etc

• Gestion des erreurs et des expressions non prises en charge

• Représentation JSON

• Encodage JSON et décodage des AST

• Performance

• Désactivation de Xdebug

• Réutiliser des objets

• Impact de la collecte des déchets

• Questions fréquemment posées

• Références des parents et des frères et sœurs