Referencia del AST

Árbol sintáctico abstracto de Achronyme: enums, campos y rastreo de spans.

Visión general

• AST con propiedad, construido a mano. Sin rowan, sin Rc, sin interning en esta capa.
• Archivo: crates/achronyme-parser/src/ast.rs
• Cada nodo lleva un Span. Re-exportado desde crates/diagnostics/src/span.rs.
• Cada Expr lleva un ExprId(u32) — denso, único dentro de un Program. Usado por el resolver para adjuntar SymbolId vía un HashMap<ExprId, SymbolId> paralelo en lugar de mutar el AST.
• Las expresiones sintéticas generadas por el compilador usan ExprId::SYNTHETIC = 0. Los IDs reales asignados por el parser comienzan en 1.
• El AST es inmutable después del parseo. Los pases de lowering (ProveIR, bytecode) leen el árbol y emiten nuevos IRs; nunca reescriben nodos.

Span / posición en el código fuente

pub struct Span {
    pub byte_start: usize,
    pub byte_end: usize,
    pub line_start: usize,
    pub col_start: usize,
    pub line_end: usize,
    pub col_end: usize,
}

pub struct SpanRange {
    pub start: Span,
    pub end: Span,
}

Los spans están basados en byte-offset para hacer slicing del código fuente original y basados en (line, col) para diagnósticos visibles al usuario. SpanRange se usa cuando el span de un nodo realmente necesita dos anclas (p.ej., un if/else cuya rama else vive lejos del encabezado).

Tope: Program

pub struct Program {
    pub stmts: Vec<Stmt>,
}

Un Program es la unidad de parseo. Cada archivo de entrada se convierte en un Program; las importaciones de módulos se resuelven por separado recorriendo Stmt::Import y re-parseando cada archivo referenciado en su propio Program.

Enum Stmt

De crates/achronyme-parser/src/ast.rs:52-141:

Enum Expr

De crates/achronyme-parser/src/ast.rs:188-331. Cada variante lleva id: ExprId y span: Span además de los campos listados.

Literales

Nombres + acceso

Operadores

Control + estructura

Compuestas

Recuperación

Operadores

pub enum BinOp {
    Add, Sub, Mul, Div, Mod, Pow,
    Eq, Neq, Lt, Le, Gt, Ge,
    And, Or,
}

pub enum UnaryOp {
    Neg, Not,
}

BinOp cubre todos los operadores infijos en la tabla de precedencia. No hay nodo separado para el ternario — se desugara a If en tiempo de parseo, así los pases posteriores solo ven una forma de condicional.

Tipos auxiliares

pub struct CallArg {
    pub name: Option<String>,   // None = positional, Some("x") = keyword
    pub value: Expr,
}

pub enum ElseBranch {
    Block(Block),
    If(Box<Expr>),    // chained else-if
}

pub enum ForIterable {
    Range { start: u64, end: u64 },              // 0..10
    ExprRange { start: u64, end: Box<Expr> },    // 0..n  (dynamic upper bound, circuit mode)
    Expr(Box<Expr>),                             // for x in arr
}

pub enum MapKey {
    Ident(String),
    StringLit(String),
}

pub enum FieldRadix {
    Decimal,
    Hex,
    Bin,
}

pub enum BigIntRadix {
    Decimal,
    Hex,
    Bin,
}

pub struct InputDecl {
    pub name: String,
    pub type_ann: Option<TypeAnnotation>,
}

pub struct TypedParam {
    pub name: String,
    pub type_ann: TypeAnnotation,
}

pub struct TypeAnnotation {
    pub visibility: Option<Visibility>,
    pub base: BaseType,
    pub array_size: Option<usize>,
}

pub enum Visibility {
    Public,
    Witness,
}

pub enum BaseType {
    Field,
    Bool,
    Int,
    String,
}

ForIterable::ExprRange es la variante introducida para límites de loop paramétricos en modo circuito: for i in 0..n donde n es un parámetro de plantilla o un var conocido en tiempo de compilación. El pase de lowering evalúa end a un u64 antes de desenrollar.

TypeAnnotation::array_size es Some(n) para arrays de tamaño fijo (Field[8]) y None para Field[] en parámetros de prove(...) donde el tamaño se captura desde el alcance llamante.

Asignación de ExprId

• IDs u32 densos, asignados por el parser a medida que recorre el código fuente.
• El Program completo es la arena de IDs; las comparaciones cross-program no son significativas (p.ej., ExprId(42) en foo.ach y ExprId(42) en bar.ach no están relacionados).
• ExprId::SYNTHETIC = 0 está reservado para nodos generados por el compilador (principalmente dentro del lowering de Circom y el compilador de ProveIR cuando sintetiza expresiones auxiliares durante la instanciación de plantillas).
• El pase del resolver anota cada ExprId con un SymbolId en SymbolTable. Ver crates/resolve/src/annotate.rs. El resolver no muta el AST — construye una tabla lateral indexada por ExprId.
• Esta forma (AST inmutable + anotaciones de tabla lateral) es lo que hace barato al LSP: el resolver corre en microsegundos y descarta sus tablas cuando el AST es invalidado.

Archivos fuente

Ver Gramática y Lexer para la sintaxis de superficie. Ver Visión General del Pipeline para qué pasa después del parseo.