Pipeline de compilación

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

flowchart TB
    subgraph SRC["📄 Código Fuente"]
        S(["`**source.fa**`"])
    end
    subgraph LEX["FASE 1 · Lexer"]
        L(["`**Lexer** lexer.rs
            texto → tokens`"])
    end
    subgraph PAR["FASES 2-3 · Parser"]
        P(["`**Parser** parser.rs
            tokens → AST
            _recursive descent_`"])
    end
    subgraph SEM["FASE 4 · Semántica"]
        TC(["`**Type Checker**
            semantics.rs
            inferencia de tipos`"])
        BC(["`**Borrow Checker**
            semantics.rs
            ownership · scoping`"])
    end
    subgraph OPT["FASE 4c · Optimización"]
        O(["`**Optimizer** optimizer.rs
            constant folding
            dead code elimination`"])
    end
    subgraph GEN["FASE 5 · Generación"]
        TR(["`**Transpilador**
            transpiler.rs
            Forja → Rust`"])
        BG(["`**Bytecode**
            bytecode.rs
            AST → Opcodes`"])
        UO(["`**Uops**
            uops.rs
            micro-opcodes`"])
        AS(["`**Compilador ASM**
            compiler_asm.rs
            Forja → Assembly`"])
    end
    subgraph VM["FASE 6 · Ejecución"]
        V3(["`**VM v3 DT**
            vm_jit.rs
            direct threading`"])
        V5(["`**VM v5 Fast** 🏆
            vm_fast.rs
            NaN tagging`"])
        J(["`**NativeJIT**
            jit.rs + jit_engine.rs
            código máquina`"])
        G(["`**gcc -O2** → .exe`"])
    end
    subgraph DIST["FASE 7 · Distribución"]
        A(["`**AOT + Selfrun**
            aot.rs + selfrun.rs
            .exe autónomo`"])
        W(["`**WASM**
            forja-wasm
            playground web`"])
    end

    S --> L --> P --> TC --> BC --> O
    O --> TR & BG & AS
    BG --> UO
    UO --> V3 & V5
    V5 --> J
    AS --> G --> A
    J --> A --> W

    TR -.-> R(["`📄 Rust (.rs)`"])
    UO -.-> B(["`💾 Bytecode (.fbc)`"])
    AS -.-> Sa(["`📄 Assembly (.s)`"])
    G -.-> E(["`⚡ Ejecutable (.exe)`"])
    W -.-> Pg(["`🌐 WebAssembly`"])

    classDef src fill:#2d2d3d,stroke:#7c7c9e,color:#fff
    classDef lx fill:#1a3a5c,stroke:#4a8ccf,color:#e0e0e0
    classDef pr fill:#2d5a1e,stroke:#5cb84a,color:#e0e0e0
    classDef sm fill:#5a2d1e,stroke:#c8783a,color:#e0e0e0
    classDef op fill:#3a2d5a,stroke:#8a5ac8,color:#e0e0e0
    classDef gn fill:#1e3a3a,stroke:#3aa0a0,color:#e0e0e0
    classDef vm fill:#3a1e3a,stroke:#c060c0,color:#e0e0e0
    classDef ds fill:#2a2a1e,stroke:#a0a040,color:#e0e0e0
    classDef ot fill:#333,stroke:#666,color:#999,stroke-dasharray:4 4

    class S src; class L lx; class P pr; class TC,BC sm; class O op
    class TR,BG,UO,AS gn; class V3,V5,J,G vm; class A,W ds
    class R,B,Sa,E,Pg ot
  

Rutas según el comando

flowchart LR
    C1["`**forja run**`"] --> R1["Lexer → Parser → TC → BC → Opt → Bytecode → Uops → **ForjaFast v5**"]
    C2["`**forja build**`"] --> R2["Lexer → Parser → TC → BC → Opt → Bytecode → **AOT + Selfrun** → .exe"]
    C3["`**forja build-asm**`"] --> R3["Lexer → Parser → **Compiler ASM** → .s → gcc −O2 → .exe"]
    C4["`**forja .fa**`"] --> R4["Lexer → Parser → TC → BC → Opt → **Transpilador** → Rust (.rs)"]
    C5["`**forja repl**`"] --> R5["Lexer → Parser → Bytecode → **ForjaFast**"]
    C6["`**forja fmt**`"] --> R6["Lexer → Parser → **Formatter**"]
    C7["`**forja diagrama**`"] --> R7["Lexer → Parser → **DiagramGenerator** → HTML"]

    classDef cmd fill:#1a1a2e,stroke:#4a4a8f,color:#fff
    classDef rt fill:#1e3a2e,stroke:#3aa060,color:#e0e0e0
    class C1,C2,C3,C4,C5,C6,C7 cmd
    class R1,R2,R3,R4,R5,R6,R7 rt
  

Fases del pipeline

flowchart TB
    F1["1 · Lexer · lexer.rs · texto → Vec<Token>"]
    F2["2-3 · Parser · parser.rs · Vec<Token> → Programa (AST)"]
    F4A["4a · Type Checker · semantics.rs · inferencia de tipos"]
    F4B["4b · Borrow Checker · semantics.rs · ownership · scoping"]
    F4C["4c · Optimizer · optimizer.rs · constant folding + DCE"]
    F5A["5a · Transpilador · transpiler.rs · AST → Rust (.rs)"]
    F5B["5b · Bytecode · bytecode.rs + uops.rs · AST → Opcodes → Uops"]
    F5D["5d · Assembly · compiler_asm.rs · AST → .s (x86-64 / ARM64)"]
    F6A["6a · VMs · vm_jit.rs / vm_fast.rs · bytecode → Output"]
    F6B["6b · JIT Engine · jit_engine.rs + jit.rs · código máquina"]
    F7["7 · AOT + Selfrun · aot.rs + selfrun.rs · .exe autónomo"]

    F1 --> F2 --> F4A --> F4B --> F4C
    F4C --> F5A & F5B & F5D
    F5B --> F6A & F6B
    F6A & F6B --> F7

    classDef ph fill:#1a2a3a,stroke:#4a7a9f,color:#e0e0e0
    class F1,F2,F4A,F4B,F4C,F5A,F5B,F5D,F6A,F6B,F7 ph
  

Los 60+ módulos del proyecto

API pública (lib.rs)

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

/// 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.