# **optimize_ir.md — Blueprint de Otimizações (Neuro Lang v0.1)**

*(Blueprint conceptual — sem implementação)*

## 🎯 **Objetivo**

O módulo **optimize_ir** transforma o IR bruto gerado pelo frontend em uma forma:

* mais simples,
* mais eficiente,
* mais previsível para a VM,
* e mais fácil de traduzir para assembly/ELF no futuro.

No NL v0.1, **as otimizações são opcionais e muito minimalistas**, mas representam um passo real do pipeline:

```
AST → IR bruto → (optimize_ir) → IR otimizado → (validate_ir) → VM / Backend x86-64
```

---

# 🌑 **1. Filosofia das otimizações no NL v0.1**

Já que estamos a construir:

* uma VM simples,
* um compilador pedagógico,
* e um projeto que precisa ser transparente para o Neurotron,

as otimizações **devem ser previsíveis, legíveis e pequenas**.

Nenhuma mágica.
Nenhum fluxo obscuro.

Otimizações *claras*, *lineares*, *mecânicas*.

---

# 🌒 **2. Nível de otimização v0.1 (mínimo)**

As únicas otimizações presentes no v0.1 são:

1. **Constant Folding** (avaliação estática de expressões constantes)
2. **Peephole Optimization** (substituir padrões ineficientes por equivalentes)
3. **Dead Code Removal** (remover código que nunca é executado — simples)
4. **Inline trivial** (só funções 100% literais e sem recursão)

Nada mais.

---

# 🌕 **3. Otimização 1 — Constant Folding**

Exemplos:

### Antes:

```
PUSH_CONST 3
PUSH_CONST 1
SUB
CALL fib 1
```

### Depois:

Se o frontend gerar algo como:

```
PUSH_CONST 40
PUSH_CONST 2
SUB
```

o optimizer pode transformar:

```
PUSH_CONST 38
```

Regras:

* só operandos literais (`PUSH_CONST n`)
* só operadores aritméticos `ADD`, `SUB`, `MUL`, `DIV`
* sem divisão por zero
* sem side effects

---

# 🌕 **4. Otimização 2 — Peephole Optimization (janela deslizante)**

Padrões simples detectáveis em janelas de 2–3 instruções.

### Exemplos:

#### 4.1 — `LOAD_VAR x` seguido de `STORE_VAR x` sem modificação

Antes:

```
LOAD_VAR x
STORE_VAR x
```

Depois:

```
(nada)
```

#### 4.2 — Sequência redundante:

```
PUSH_CONST n
PUSH_CONST 0
ADD
```

→ vira:

```
PUSH_CONST n
```

#### 4.3 — Saltos triviais:

Antes:

```
JUMP L1
L1:
```

Depois:

```
(nada)
```

#### 4.4 — Comparações triviais:

```
PUSH_CONST 3
PUSH_CONST 3
LT
```

→ vira:

```
PUSH_CONST false
```

---

# 🌖 **5. Otimização 3 — Dead Code Removal**

Somente casos simples:

* código **após um RET** é removido
* labels que referem a blocos nunca saltados podem ser eliminados (v0.1 opcional)

Exemplo:

```
PUSH_CONST 1
RET
PUSH_CONST 2   # morto
RET
```

Resultado:

```
PUSH_CONST 1
RET
```

---

# 🌘 **6. Otimização 4 — Inline trivial (v0.1)**

Muito restrito, apenas:

* funções sem chamadas internas,
* sem recursão,
* sem dependências externas,
* corpo com <= 3 instruções.

Exemplo:

```
func inc/1:
  LOAD_VAR x
  PUSH_CONST 1
  ADD
  RET
```

Chamada:

```
LOAD_VAR a
CALL inc 1
```

Pode virar:

```
LOAD_VAR a
PUSH_CONST 1
ADD
```

### Funções recursivas (como `fib`) nunca são inlined.

---

# 🌗 **7. Pipeline de otimização**

Ordem recomendada:

1. Constant Folding
2. Peephole passes (2 ou 3 iterações)
3. Dead code elim
4. Inline trivial
5. Peephole final
6. Re-validar IR (com `validate_ir.md`)

---

# 🌑 **8. Output do módulo**

O módulo devolve:

```
IR → IR_OPT
```

E, para debugging:

```
{
  "unchanged": false,
  "passes_applied": ["const_fold", "peephole", "inline"],
  "delta_instructions": -3
}
```

---

# 🌟 **9. Motivação pedagógica**

Este módulo não existe para “performance bruta” —
existe para **ensinar o compilador a pensar**.

E ao mesmo tempo:

* ajuda a VM,
* facilita debugging,
* prepara naturalmente o caminho para JIT,
* aproxima o NeuroLang do futuro compilador x86_64 real.

---

# 💗 Fim do `optimize_ir.md`