Apresentando o ACER: Um Novo Framework para Geração de Grafos de Chamadas

Apresentamos o ACER, um framework feito pra criar Gráficos de Chamadas baseados em árvores de sintaxe abstrata (ASTs). Gráficos de chamadas ajudam a analisar como os Métodos de um programa interagem entre si, o que pode ajudar em várias tarefas, tipo otimizar código ou achar problemas de segurança. A gente foca em usar ASTs porque dá pra processar rápido e fácil em várias situações.

#O que é um Gráfico de Chamadas?

Um gráfico de chamadas é um diagrama que mostra quais métodos chamam quais outros métodos num programa. Nesse gráfico, cada método é um ponto (ou vértice), e cada chamada de um método pra outro é uma linha (ou aresta) conectando esses pontos. Por exemplo, se o Método A chama o Método B, vai ter uma linha direcionada de A pra B no gráfico de chamadas.

#Importância dos Gráficos de Chamadas

Os gráficos de chamadas são importantes pra várias coisas. Eles ajudam a melhorar o desempenho do software, localizar potenciais problemas de segurança e auxiliar na reestruturação ou refatoração do código. Mapeando como as diferentes partes do código funcionam juntas, os desenvolvedores conseguem tomar decisões melhores sobre modificações e melhorias.

#Como Funcionam os Geradores de Gráficos de Chamadas

Os geradores de gráficos de chamadas analisam o código-fonte pra criar esses gráficos. O processo envolve descobrir onde os métodos são chamados e resolver as chamadas pra métodos específicos. Existem alguns desafios nesse processo, especialmente em linguagens que permitem comportamento dinâmico.

#Tipos de Geradores de Gráficos de Chamadas

1. Geradores Simples: Esses identificam chamadas rapidamente, baseados principalmente nos nomes dos métodos, sem considerar detalhes como os receptores dos métodos.
2. Geradores Insensíveis ao Contexto: Esses olham o código mais de perto e analisam o contexto das chamadas de métodos, mas ainda perdem alguns detalhes.
3. Geradores Sensíveis ao Contexto: Esses tomam a abordagem mais detalhada, considerando o contexto completo das chamadas de métodos pra produzir gráficos mais precisos.

Os geradores também podem diferir baseados em que parte do software eles analisam - só a aplicação, as bibliotecas ou uma combinação. O formato de origem usado durante a análise também afeta a performance do Gerador.

#Por que Usamos ASTs

Nosso sistema depende de ASTs porque elas permitem analisar o código sem precisar compilar tudo. Isso torna o processo mais rápido e aplicável a várias linguagens de programação. ASTs oferecem uma versão simplificada da estrutura do código que é mais fácil de trabalhar do que o código-fonte bruto.

#Visão Geral do Framework ACER

O framework ACER tem dois componentes principais:

1. Tree-sitter: Essa é uma biblioteca que ajuda a transformar código em estruturas de árvore. Ela fornece um jeito de trabalhar com a sintaxe de várias linguagens de programação.
2. Utilitários Comuns: Esses componentes têm lógica compartilhada útil pra diferentes tipos de geradores, facilitando a criação de novos.

Combinando essas duas partes, o ACER busca oferecer um jeito simples de criar geradores de gráficos de chamadas.

#Construindo um Gerador de Gráficos de Chamadas

Pra criar um gerador usando o ACER, os desenvolvedores podem estender classes existentes e implementar métodos específicos. Uma classe importante, a Pré-processadora, prepara o código de entrada pra análise. Ela constrói estruturas de busca que o gerador vai usar ao criar o gráfico de chamadas.

O Gerador então pega os dados preparados, encontra todos os pontos de chamada no código e determina quais métodos estão sendo chamados baseado nas estruturas construídas pela Pré-processadora.

#Desafios na Geração de Gráficos de Chamadas

Criar gráficos de chamadas precisos pode ser complicado, especialmente ao lidar com características de linguagens de programação como polimorfismo (onde uma única função pode trabalhar com diferentes tipos de dados) e ambiguidade (onde não tá claro qual método tá sendo chamado baseado nas informações disponíveis).

#Exemplos de Ambiguidade

Um exemplo de ambiguidade é quando um método é sobrecarregado, ou seja, existem vários métodos com o mesmo nome, mas com tipos de parâmetros diferentes. Sem analisar o contexto todo (como as fontes das bibliotecas), pode ser impossível pra um gerador determinar qual versão do método tá sendo chamada.

#Descrição da Ferramenta e Implementação

O framework ACER consiste em dois componentes principais: a Pré-processadora e o Gerador.

#Pré-processadora

A Pré-processadora é responsável por ler o código de entrada e criar estruturas que o Gerador vai precisar. Ela usa tree-sitter pra analisar o código em estruturas de árvore e, em seguida, constrói um dicionário de métodos pra mapear nomes de métodos às suas definições. Além disso, ela cria um dicionário único pra lidar com potenciais conflitos de nome.

#Gerador

O Gerador pega a saída da Pré-processadora e cria o gráfico de chamadas. Ele primeiro identifica os pontos de chamada, que são lugares no código onde os métodos são invocados. Depois, ele resolve essas chamadas pros métodos reais que estão sendo referenciados. Por exemplo, se uma chamada de método parece com a.b(), o Gerador vai examinar a pra determinar que tipo é e qual método b() pertence.

#Avaliação de Performance

Implementamos dois tipos de geradores usando o ACER: um baseado em uma abordagem simples de resolução de nomes e outro usando uma análise simples da hierarquia de classes. Avaliamos esses geradores em relação a ferramentas existentes pra ver como eles se saiam em termos de velocidade e precisão.

Os resultados mostraram que enquanto geradores mais simples podiam produzir muitas arestas (conexões entre métodos), eles muitas vezes faltavam precisão. Os geradores mais complexos tendiam a produzir menos arestas, mas eram mais precisos nas suas conexões.

#Planos Futuros

A gente planeja fazer mais análises sobre a eficiência dos nossos geradores e trabalhar em melhorias que poderiam aperfeiçoar a resolução de nomes e métodos. Além disso, queremos criar geradores pra outras linguagens de programação pra mostrar a flexibilidade do framework ACER.

#Conclusão

Resumindo, o ACER é um framework voltado pra simplificar o processo de gerar gráficos de chamadas a partir do código. Ele aproveita as ASTs pra uma análise rápida e usa o tree-sitter pra uma análise eficiente. Embora existam desafios em resolver chamadas de métodos com precisão, o framework fornece as ferramentas e estruturas necessárias pra construir geradores de gráficos de chamadas confiáveis. O trabalho futuro vai focar em refinar essas ferramentas e expandir sua aplicabilidade pra mais linguagens de programação.