Struct CodeGenerator

pub struct CodeGenerator {
    pub chunk: Chunk,
    line: usize,
    variables: Vec<String>,
    functions: Vec<String>,
    local_scopes: Vec<Vec<String>>,
    errors: Vec<CompilerError>,
}

Compiles AST nodes into bytecode instructions

Fields

chunk: Chunk

The bytecode chunk being constructed

line: usize

Current line number for debugging information

variables: Vec<String>

Global variable names

functions: Vec<String>

Function names for tracking declarations

local_scopes: Vec<Vec<String>>

Stack of scopes for tracking local variables

errors: Vec<CompilerError>

Accumulated errors during compilation

Implementations

impl CodeGenerator

pub fn new() -> Self

Creates a new compiler with an empty chunk

fn set_current_location(&mut self, location: &Location)

Updates the current line from a source location

fn add_error(&mut self, message: String)

Creates a CompilerError with the current location and adds it to the error list

fn compile(self, statements: &[Statement]) -> CompileResult<Chunk>

Compiles a list of statements into bytecode

Arguments

• statements - The statements to compile

Returns

A CompileResult containing the compiled bytecode chunk or errors

pub fn compile_statements( &mut self, statements: &[Statement], ) -> CompileResult<()>

Compiles statements and appends them to the existing chunk

Arguments

• statements - The statements to compile

Returns

CompileResult indicating success or containing errors

pub fn get_chunk(&self) -> &Chunk

Gets a reference to the current chunk

fn emit_byte(&mut self, byte: u8)

Emits a single byte to the bytecode chunk

Arguments

• byte - The byte to emit

fn emit_op(&mut self, op: OpCode)

Emits an opcode to the bytecode chunk

Arguments

• op - The opcode to emit

fn emit_constant(&mut self, value: Value) -> Result<(), ()>

Adds a constant value to the chunk and emits code to load it

Arguments

• value - The constant value to add

fn emit_jump(&mut self, op: OpCode) -> usize

Emits a jump instruction with placeholder offset

Arguments

• op - The jump opcode (Jump or JumpIfFalse)

Returns

The position where the jump offset needs to be patched later

fn patch_jump(&mut self, offset: usize)

Patches a previously emitted jump instruction with the actual offset

Arguments

• offset - The position of the jump offset to patch

fn begin_scope(&mut self)

fn end_scope(&mut self)

Trait Implementations

impl Visitor<Result<(), ()>> for CodeGenerator

fn visit_statement(&mut self, stmt: &Statement) -> Result<(), ()>

Visit a general statement

fn visit_expression(&mut self, expr: &Expression) -> Result<(), ()>

Visit a general expression

fn visit_function_declaration_statement( &mut self, fn_decl: &FunctionDeclarationStmt, ) -> Result<(), ()>

Visit a function declaration statement

fn visit_return_statement( &mut self, return_stmt: &ReturnStatement, ) -> Result<(), ()>

Visit a return statement

fn visit_expression_statement(&mut self, expr: &Expression) -> Result<(), ()>

Visit an expression statement

fn visit_let_statement(&mut self, let_stmt: &LetStatement) -> Result<(), ()>

Visit a variable declaration statement

fn visit_assignment_statement( &mut self, assign_stmt: &AssignmentStatement, ) -> Result<(), ()>

Visit a variable assignment statement

fn visit_call_expression( &mut self, call_expr: &FunctionCallExpr, ) -> Result<(), ()>

Visit a function call expression

fn visit_literal_expression(&mut self, lit_expr: &LiteralExpr) -> Result<(), ()>

Visit a literal expression (e.g., 42, “hello”)

fn visit_binary_expression(&mut self, bin_expr: &BinaryExpr) -> Result<(), ()>

Visit a binary expression (e.g., a + b)

fn visit_unary_expression(&mut self, unary_expr: &UnaryExpr) -> Result<(), ()>

Visit a unary expression (e.g., -x)

fn visit_variable_expression( &mut self, var_expr: &VariableExpr, ) -> Result<(), ()>

Visit a variable reference expression

fn visit_type_definition_statement( &mut self, _stmt: &TypeDefinitionStmt, ) -> Result<(), ()>

Visit a type definition statement

fn visit_conditional_expression( &mut self, cond_expr: &ConditionalExpr, ) -> Result<(), ()>

Visit a conditional expression (if/else)

fn visit_if_statement(&mut self, if_stmt: &IfStatement) -> Result<(), ()>

Visit a conditional statement (if/else)

fn visit_block_expression(&mut self, block_expr: &BlockExpr) -> Result<(), ()>

Visit a block expression

fn visit_function_type_expression( &mut self, _func_type_expr: &FunctionTypeExpr, ) -> Result<(), ()>

Visit a function type expression (e.g., fn(i32, string) -> string)