Micro compilador em Rust - Ilustrando mais um grande caso de uso · ktfth

Abaixo segue um artigo sobre o micro compilador, incluindo o código disponibilizado em um repositório no GitHub. O objetivo é mostrar como esse projeto pode auxiliar nos estudos iniciais de construção de compiladores e entendimento de pipelines de compilação, desde a análise léxica até a geração de código JavaScript.

Código Disponível:
O código-fonte do micro compilador pode ser acessado diretamente no GitHub:
https://github.com/ktfth/microcomp

Introdução

A construção de compiladores é frequentemente vista como um tópico avançado, repleto de detalhes e complexidades que só se tornam mais claros após um período significativo de estudo. Entretanto, contar com um compilador minimalista, escrito em uma linguagem segura e moderna como Rust, pode facilitar bastante a jornada. Esse micro compilador tem como objetivo fornecer um ponto de partida simples e didático, permitindo que estudantes e curiosos entendam o processo de compilação passo a passo.

O projeto disponibilizado apresenta uma linguagem extremamente simples, com declarações de variáveis, expressões aritméticas e uma função de impressão básica. A partir daí, todo o pipeline tradicional de um compilador é demonstrado:

Análise Léxica (Lexer): Transforma o código-fonte em tokens.
Análise Sintática (Parser): Converte a sequência de tokens em uma Árvore Sintática Abstrata (AST).
Análise Semântica: Verifica se o código faz sentido (por exemplo, se variáveis foram declaradas antes do uso).
Geração de Código: A AST é transformada em código de saída, neste caso, JavaScript, permitindo execução posterior.

O uso de crates do ecossistema Rust, como logos para análise léxica e pest para análise sintática, além de um design modular e limpo, reduz a complexidade do código base. Dessa forma, o estudante pode focar na lógica do compilador em si, ao invés de gastar tempo implementando todas as etapas do zero.

Por Que um Micro Compilador?

Compreensão Progressiva: Ao lidar com um compilador simples, é possível entender o processo por partes. Você pode começar entendendo como o Lexer converte cadeias de caracteres em tokens, depois avançar para o Parser e, por fim, chegar à geração de código.
Facilidade na Extensão da Linguagem: Por ter um núcleo minimalista, fica relativamente simples adicionar novas construções à linguagem. Comece com expressões aritméticas básicas e, aos poucos, inclua condicionais, loops, funções e outros recursos.
Rust: Segurança e Concisão: Rust é conhecida por sua segurança de memória e expressividade. Estudantes podem aprender a construir compiladores ao mesmo tempo em que adquirem experiência com essa linguagem moderna, fortalecendo conhecimentos de programação de sistemas.

Arquitetura do Micro Compilador

A arquitetura do compilador segue o padrão clássico:

Lexer (Análise Léxica):
Utiliza a crate logos para converter o código fonte, por exemplo:
```
let x = 10;
let y = 20;
print(x + y * 2);
```
em uma lista de tokens como LET, IDENT(x), ASSIGN, NUMBER(10), SEMICOLON, etc.
Parser (Análise Sintática):
Com pest, o código é mapeado para uma gramática declarativa. Assim, let x = 10; torna-se um nó da AST representando uma declaração de variável, enquanto print(x + y * 2); gera uma árvore que representa a chamada de função com uma expressão binária.
AST (Árvore Sintática Abstrata):
A AST é um modelo intermediário do código. Cada nó da árvore representa um constructo da linguagem. Por exemplo, uma declaração de variável ou uma operação aritmética. Isso facilita a próxima etapa.
Análise Semântica:
Antes de gerar código, o compilador verifica se o programa faz sentido semanticamente. Isso inclui checar se variáveis estão declaradas antes do uso ou se as operações são válidas.
Geração de Código (Code Generation):
Ao invés de gerar código nativo, este micro compilador produz código JavaScript. Assim, let x = 10; let y = 20; print(x + y * 2); se torna algo como:
```
let x = 10;
let y = 20;
console.log((x + (y * 2)));
```
Esse resultado pode ser facilmente executado com node output.js ou integrado a outros ambientes.

Como Esse Projeto Ajuda nos Estudos?

Exemplo Prático e Concreto: Não se trata de teoria isolada. O estudante pode alterar o código, adicionar novas funções, mudar o back-end de geração de código, testar entradas diferentes e ver imediatamente o efeito.
Feedback Rápido: Por ser um projeto pequeno, a recompilação e execução são rápidas. Isso permite um ciclo de iteração curto, ideal para aprendizagem.
Ponto de Partida para Projetos Maiores: Aprendendo o básico aqui, é mais fácil avançar para compiladores mais complexos ou mesmo contribuir para projetos reais de compilação.

Como Usar

Clonar o Repositório:

git clone https://github.com/ktfth/microcomp.git
cd microcomp

Compilar e Executar:
```
cargo run -- caminho/do/arquivo.mc
```
Onde arquivo.mc é um arquivo fonte com sua mini linguagem. Após a execução, um arquivo output.js será gerado.
Executar o Código Gerado:
```
node output.js
```
Verifique se você tem o Node.js instalado.

Conclusão

Este micro compilador em Rust serve como uma introdução prática ao mundo da construção de compiladores. Ao fornecer um pipeline completo, desde a análise léxica até a geração de código JavaScript, ele ajuda iniciantes a compreenderem cada parte do processo. Além disso, sua arquitetura simples e modular permite experimentação fácil, sendo um ótimo trampolim para projetos mais sofisticados no futuro.

Para acessar o código e começar a explorar, visite o repositório: https://github.com/ktfth/microcomp.