PHP Parser

Analisador PHP

Este é um analisador PHP escrito em PHP. Seu objetivo é simplificar a análise e manipulação de código estático.

Documentação para a versão 5.x (atual; para execução em PHP >= 7.4; para análise de PHP 7.0 a PHP 8.4, com suporte limitado para análise de PHP 5.x).

Documentação para a versão 4.x (suportada; para execução em PHP >= 7.0; para análise de PHP 5.2 a PHP 8.3).

Características

Os principais recursos fornecidos por esta biblioteca são:

• Análise de código PHP 7 e PHP 8 em uma árvore de sintaxe abstrata (AST).

• O código inválido pode ser analisado em um AST parcial.

• O AST contém informações de localização precisas.

• Despejando o AST em formato legível por humanos.

• Convertendo um AST de volta para código PHP.

• A formatação pode ser preservada para ASTs parcialmente alterados.

• Infraestrutura para percorrer e modificar ASTs.

• Resolução de nomes com namespace.

• Avaliação de expressões constantes.

• Construtores para simplificar a construção AST para geração de código.

• Convertendo um AST em JSON e vice-versa.

Início rápido

Instale a biblioteca usando o compositor:

php composer.phar require nikic/php-parser

Analise algum código PHP em um AST e despeje o resultado em um formato legível:

 <?phpuse PhpParserError;use PhpParserNodeDumper;use PhpParserParserFactory;$code = <<<'CODE'<?phpfunction test($foo){ var_dump($foo);}CODE;$parser = (new ParserFactory())->createForNewestSupportedVersion ();tente {$ast = $parser->parse($código);
} catch (Erro $error) {echo "Erro de análise: {$error->getMessage()}n";return;
}$dumper = new NodeDumper;echo $dumper->dump($ast) . "n";

Isso despeja um AST parecido com isto:

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
                        )
                    )
                )
            )
        )
    )
)

Vamos percorrer o AST e realizar algum tipo de modificação. Por exemplo, elimine todos os corpos funcionais:

 use PhpParserNode;use PhpParserNodeStmtFunction_;use PhpParserNodeTraverser;use PhpParserNodeVisitorAbstract;$traverser = new NodeTraverser();$traverser->addVisitor(nova classe estende NodeVisitorAbstract {public function enterNode(Node $node) {if ($node instanceof Function_) {// Limpar a função body$node->stmts = [];
        }
    }
});$ast = $traverser->traverse($ast);echo $dumper->dump($ast) . "n";

Isso nos dá um AST onde Function_::$stmts está vazio:

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(
        )
    )
)

Finalmente, podemos converter o novo AST de volta para código PHP:

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

Isso nos dá nosso código original, menos a chamada var_dump() dentro da função:

 <?phpfunção teste($foo)
{
}

Para uma introdução mais abrangente, consulte a documentação.

Documentação

1. Introdução

2. Uso de componentes básicos

Documentação do componente:

• Caminhando pela AST

• Visitantes do nó

• Modificando o AST de um visitante

• Travessias de curto-circuito

• Visitantes intercalados

• API simples de localização de nós

• Referências de pais e irmãos

• Resolução de nomes

• Opções de resolução de nomes

• Contexto de resolução de nomes

• Impressão bonita

• Convertendo AST de volta para código PHP

• Personalizando a formatação

• Transformações de código com preservação de formatação

• Construtores AST

• Construtores fluentes para nós AST

• Lexer

• Emulação

• Tokens, posições e atributos

• Tratamento de erros

• Informações da coluna para erros

• Recuperação de erros (análise de código sintaticamente incorreto)

• Avaliação de expressão constante

• Avaliando inicializadores constantes/propriedade/etc

• Tratamento de erros e expressões não suportadas

• Representação JSON

• Codificação JSON e decodificação de ASTs

• Desempenho

• Desativando o Xdebug

• Reutilizando objetos

• Impacto da coleta de lixo

• Perguntas frequentes

• Referências de pais e irmãos