Parser para C #

Quais analisadores estão disponíveis para analisar o código C #?

Estou procurando um analisador C # que possa ser usado em C # e me dê acesso a informações de linha e arquivo sobre cada artefato do código analisado.

Funciona no código-fonte:

• CSParser : de C # 1.0 a 2.0, código-fonte aberto
• Analisador Metaspec C # : De C # 1.0 a 3.0, produto comercial (cerca de 5000 $)
• #reconhecer! : De C # 1.0 a 3.0, produto comercial (cerca de 900 €) (resposta de SharpRecognize )
• SharpDevelop Parser (resposta de Akselsson )
• NRefactory : De C # 1.0 a 4.0 (+ assíncrono), open-source, parser usado em SharpDevelop. Inclui análise semântica.
• Analisador C # e CodeDOM : Um analisador C # 4.0 completo, já oferece suporte ao recurso assíncrono C # 5.0. Produto comercial (49 $ a 299 $) (resposta de Ken Beckett )
• Microsoft Roslyn CTP : Compilador como serviço.

Trabalha na montagem:

• System.Reflection
• Microsoft Common Compiler Infrastructure : De C # 1.0 a 3.0, Microsoft Public License. Usado por Fxcop e Spec #
• Mono.Cecil : de C # 1.0 a 3.0, código-fonte aberto

O problema com a "análise" da montagem é que temos menos informações sobre a linha e o arquivo (as informações são baseadas no arquivo .pdb, e o Pdb contém informações das linhas apenas para métodos)

Eu pessoalmente recomendo Mono.Cecil e NRefactory .

Mono (código aberto) inclui compilador C # (e, claro, analisador)

Se você for compilar C # v3.5 para assemblies .net:

var cp = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } });

http://msdn.microsoft.com/en-us/library/microsoft.csharp.csharpcodeprovider.aspx

Se você estiver familiarizado com ANTLR, poderá usar a gramática Antlr C # .

Implementei exatamente o que você está pedindo (análise AST do código C #) na plataforma OWASP O2 projeto da usando APIs AST SharpDevelop.

Para torná-lo mais fácil de consumir, escrevi uma API rápida que expõe vários elementos-chave do código-fonte (usando instruções, tipos, métodos, propriedades, campos, comentários) e é capaz de reescrever o código C # original em C # e em VBNET .

Você pode ver esta API em ação neste arquivo de script O2 XRule: ascx_View_SourceCode_AST.cs.o2 .

Por exemplo, é assim que você processa um texto de código-fonte C # e preenche uma série de TreeViews e TextBoxes:

    public void updateView(string sourceCode)
    {   
        var ast = new Ast_CSharp(sourceCode);
        ast_TreeView.show_Ast(ast);
        types_TreeView.show_List(ast.astDetails.Types, "Text");
        usingDeclarations_TreeView.show_List(ast.astDetails.UsingDeclarations,"Text");
        methods_TreeView.show_List(ast.astDetails.Methods,"Text");
        fields_TreeView.show_List(ast.astDetails.Fields,"Text");
        properties_TreeView.show_List(ast.astDetails.Properties,"Text");
        comments_TreeView.show_List(ast.astDetails.Comments,"Text");

        rewritenCSharpCode_SourceCodeEditor.setDocumentContents(ast.astDetails.CSharpCode, ".cs");
        rewritenVBNet_SourceCodeEditor.setDocumentContents(ast.astDetails.VBNetCode, ".vb");                                
    }

O exemplo em ascx_View_SourceCode_AST.cs.o2 também mostra como você pode usar as informações coletadas do AST para selecionar no código-fonte um tipo, método, comentário, etc.

Para referência, aqui está o código da API que escrevi (observe que esta é minha primeira passagem usando o analisador C # AST da SharpDevelop, e ainda estou tentando entender como ele funciona):

• AstDetails.cs
• AstTreeView.cs
• AstValue.cs
• Ast_CSharp.cs

Recentemente, lançamos um analisador C # que lida com todos os recursos do C # 4.0, além do novo recurso assíncrono: Analisador C # e CodeDOM

Esta biblioteca gera um modelo de objeto semântico que retém comentários e informações de formatação e pode ser modificado e salvo. Ele também oferece suporte ao uso de consultas LINQ para analisar o código-fonte.

http://www.codeplex.com/csparser

SharpDevelop , um IDE de código aberto, vem com um analisador de código baseado em visitante que funciona muito bem. Ele pode ser usado independentemente do IDE.

Considere o uso de reflexão em um binário integrado em vez de analisar o código C # diretamente. A API de reflexão é realmente fácil de usar e talvez você possa obter todas as informações de que precisa?

Dê uma olhada no Gold Parser . Tem uma IU muito intuitiva que permite testar interativamente sua gramática e gerar código C #. Existem muitos exemplos disponíveis com ele e é totalmente gratuito.

Talvez você possa tentar com o Irony em irony.codeplex.com.

É muito rápido e já existe uma gramática c #.

A própria gramática é escrita diretamente em c # de forma semelhante ao BNF (obtida com algumas sobrecargas de operadores)

A melhor coisa com isso é que a "gramática" produz o AST diretamente.

Você definitivamente deve verificar o Roslyn, já que a MS acabou de abrir (ou abrirá em breve) o código com uma licença Apache 2 aqui . Você também pode verificar uma maneira de analisar essas informações com este código do GitHub .

Algo que está ganhando impulso e muito apropriado para o trabalho é Nemerle

você pode ver como isso poderia resolver nestes vídeos da NDC:

• Igor Tkachev - Metaprogramação com Nemerle
• Igor Tkachev - linguagem de programação Nemerle

Não em C #, mas um analisador C # 2/3/4 completo que cria ASTs completos está disponível com nosso DMS Software Reengineering Toolkit .

O DMS fornece uma vasta infraestrutura para análise, construção de árvore, construção de tabelas de símbolos e análises de fluxo, transformação de origem para origem e regeneração de código-fonte dos ASTs (modificados). (Ele também lida com muitas outras linguagens além de apenas C #.)

EDIT (setembro) 2013: Esta resposta não foi atualizada recentemente. DMS há muito lidou com C # 5.0

O GPPG pode ser útil, se você estiver disposto a escrever seu próprio analisador (o que é divertido).