Pipeline de compilación

Forja tiene un pipeline de 8+ fases que transforma código fuente .fa en código Rust, bytecode ejecutable (para 3 VMs), assembly nativo, o ejecutables autónomos.

🔀 Flujo completo

┌────────────┐
│  Source.fa │
└─────┬──────┘
      ▼
┌────────────┐   FASE 1: Lexer
│   Lexer    │   Texto → Tokens
└─────┬──────┘
      ▼
┌────────────┐   FASE 2-3: Parser
│   Parser   │   Tokens → AST (Recursive Descent)
└─────┬──────┘
      ▼
┌──────────────┐ FASE 4: Semántica
│ Type Checker │ Verificación de tipos
│ Borrow       │ Ownership, mutabilidad, scoping
│ Checker      │
└─────┬───────┘
      ▼
┌──────────────┐ FASE 4c: Optimización
│  Optimizer   │ Constant folding + Dead Code Elimination
└─────┬───────┘
      ▼
     ══╦══
   ┌───║───┐
   ▼       ▼                  ▼               ▼
┌────────┐ ┌────────────┐ ┌──────────┐ ┌──────────────┐
│ Rust   │ │ Bytecode   │ │ Assembly │ │ Formatter /  │
│ .rs    │ │ Gen + Uops │ │ .s (ASM) │ │ Diagrama     │
└────────┘ └─────┬──────┘ └────┬─────┘ └──────────────┘
                 ▼             ▼
           ┌──────────┐  ┌──────────┐
           │ 3 VMs    │  │ gcc -O2 │
           │ vm / jit │  │ .exe    │
           │ jit/fast │  └──────────┘
           │          │
           │ JIT Eng. │
           │NativeJIT │
           │+ fallback│
           └──────────┘
                 │
           ┌─────▼──────┐
           │ AOT + Self │ → .exe autónomo
           │    Run     │
           └────────────┘
                 │
           ┌─────▼──────┐
           │ WASM (web) │ → Playground navegador
           └────────────┘

Rutas según el comando

Comando	Pipeline
`forja archivo.fa`	Lexer → Parser → Type Checker → Borrow Checker → Transpilador → .rs
`forja run archivo.fa`	Lexer → Parser → Type Checker → Optimizer → Bytecode → Uops → ForjaFast v5 → Output
`forja build-asm archivo.fa`	Lexer → Parser → compiler_asm → .s → gcc -O2 → .exe
`forja build archivo.fa`	Lexer → Parser → Type Checker → Bytecode → AOT + Selfrun → .exe
`forja repl`	Por línea: Lexer → Parser → Bytecode → ForjaFast (variables persisten)
`forja fmt archivo.fa`	Lexer → Parser → Formatter → código formateado
`forja diagrama archivo.fa`	Lexer → Parser → DiagramGenerator → HTML interactivo

Fases del pipeline

Fase	Módulo(s)	Entrada	Salida
1. Lexer	`lexer.rs`	Código fuente .fa	`Vec<Token>`
2-3. Parser	`parser.rs`	`Vec<Token>`	`Programa` (AST)
4a. Type Checker	`semantics.rs`	`Programa` (AST)	AST verificado
4b. Borrow Checker	`semantics.rs`	`Programa` (AST)	AST verificado
4c. Optimizer	`optimizer.rs`	`Programa` (AST)	AST optimizado (fold + DCE)
5a. Transpilador	`transpiler.rs`	`Programa` (AST)	Código Rust (.rs)
5b. Bytecode Gen	`bytecode.rs`	`Programa` (AST)	`Vec<Opcode>`
5c. Uops (Expansión)	`uops.rs`	`Vec<Opcode>`	`Vec<Uop>` (micro-opcodes)
5d. ASM Native	`compiler_asm.rs`	`Programa` (AST)	Assembly .s (x86-64 / ARM64)
6a. VM (3 versiones)	`vm.rs`, `vm_jit.rs`, `vm_fast.rs`	`Vec<Opcode>`	Output
6b. JIT Engine	`jit_engine.rs` + `jit.rs`	`Vec<Opcode>`	Código máquina + ejecución
7. AOT + Selfrun	`aot.rs` + `selfrun.rs`	Bytecode .fbc	.exe autónomo

Los 26+ módulos del proyecto

🎯

main.rs

CLI — 15+ comandos, punto de entrada (833 líneas)

📚

lib.rs

API pública: compilar(), ejecutar(), ejecutar_jit()

🔤

token.rs

Definición de tokens del lenguaje

📖

lexer.rs

Tokenizador (texto → tokens)

🌳

ast.rs

AST definitions (nodos del árbol)

🔧

parser.rs

Parsing recursivo descendente con precedencia

🚫

error.rs

Sistema de errores educativo + salida JSON

🔍

semantics.rs

Type Checker + Borrow Checker

🦀

transpiler.rs

Forja → Rust (código compilable)

⚡

compiler_asm.rs

Forja → Assembly (2393 líneas, multi-arquitectura)

💾

bytecode.rs

Generación y serialización de bytecode (1206 líneas)

🔬

uops.rs

Micro-opcodes: expansión y optimización (463 líneas)

⚙️

vm.rs (v1)

VM stack-based original (2040 líneas)

⚡

vm_jit.rs (v3 DT)

VM Direct Threading, u8 planos (649 líneas)

🚀

vm_fast.rs (v5) 🏆

VM ultra rápida, NaN tagging, stack caching, producción (3610 líneas)

🔥

jit.rs

NativeJIT: código máquina x86-64 en memoria (20+ opcodes)

🔀

jit_engine.rs

Orquestador JIT nativo con fallback a ForjaFast

📐

optimizer.rs

Constant folding + Dead Code Elimination

🎨

formatter.rs

Formateador de código Forja

📊

diagrama.rs

Generador de diagramas HTML del AST

💬

repl.rs

REPL interactivo con rustyline

📦

aot.rs

Compilador AOT (.exe autónomo)

🏃

selfrun.rs

Bytecode embed + auto-ejecución

🧩

module.rs

Resolvedor de módulos (+ seguridad anti path traversal)

📋

prelude.rs

Prelude del lenguaje

🌐

forja-wasm

Bindings WASM para el playground web

API pública (lib.rs)

Estas son las funciones principales que expone la biblioteca para usar Forja desde Rust:

📄 API de compilación y ejecución

/// Compila .fa → código Rust (pipeline completo con Optimizer)
pub fn compilar(source: &str) -> Result<String, Vec<ErrorForja>>;

/// Compila y ejecuta código Forja en ForjaFast v5 (VM producción)
pub fn ejecutar(source: &str) -> Result<Vec<String>, String>;

/// Compila y ejecuta con JIT Nativo (x86-64), fallback a ForjaFast
pub fn ejecutar_jit(source: &str) -> Result<Vec<String>, String>;

La función compilar() ejecuta: Lexer → Parser → Type Checker → Borrow Checker → Optimizer → DCE → Transpilador.
La función ejecutar() ejecuta: Lexer → Parser → Type Checker → Optimizer → DCE → Bytecode Generator → optimizar_indices → fusionar_opcodes → ForjaFast v5.