Struct BytecodeCompiler 

pub struct BytecodeCompiler {
    pub stdlib_function_names: HashSet<String>,
    /* private fields */
}

Compiler state

Fields

stdlib_function_names: HashSet<String>

Legacy cache of function names collected from stdlib-loaded modules.

Internal builtin access is now gated by per-definition declaring-module provenance, not by membership in this set.

Implementations

impl BytecodeCompiler

pub fn type_tracker(&self) -> &TypeTracker

Get the type tracker (for external configuration)

pub fn type_tracker_mut(&mut self) -> &mut TypeTracker

Get mutable type tracker (for registering types)

impl BytecodeCompiler

pub fn register_imported_items(&mut self, items: &[Item])

Pre-register items from an imported module (enums, struct types, functions).

Called by the LSP before compilation to make imported enums/types known to the compiler’s type tracker. Reuses register_enum as single source of truth.

impl BytecodeCompiler

pub fn new() -> Self

pub fn set_comptime_mode(&mut self, enabled: bool)

Enable comptime compilation mode for this compiler instance.

pub fn set_blob_cache(&mut self, cache: BlobCache)

Attach a blob-level cache for incremental compilation.

When set, finalize_current_blob stores each compiled blob in the cache, and build_content_addressed_program populates the function store from cached blobs when possible.

pub fn register_known_export(&mut self, function_name: &str, module_path: &str)

Register a known export for import suggestions

This enables helpful error messages like: “Unknown function ‘sma’. Did you mean to import from ‘@stdlib/finance/indicators/moving_averages’?”

pub fn register_known_exports(&mut self, exports: &HashMap<String, String>)

Register multiple known exports at once

pub fn suggest_import(&self, function_name: &str) -> Option<&str>

Suggest an import for an unknown function

pub fn set_source(&mut self, source: &str)

Set the source text for error messages

pub fn set_source_with_file(&mut self, source: &str, file_name: &str)

Set the source text and file name for error messages

pub fn set_line(&mut self, line: u32)

Set the current source line (from AST span)

pub fn set_line_from_span(&mut self, span: Span)

Set line from a Span (converts byte offset to line number)

pub fn get_source_line(&self, line: usize) -> Option<&str>

Get a source line by line number (1-indexed)

pub fn register_known_bindings(&mut self, names: &[String])

Pre-register known root-scope bindings (for REPL persistence)

Call this before compilation to register bindings from previous REPL sessions. This ensures that references to these bindings compile to LoadModuleBinding/StoreModuleBinding instructions rather than causing “Undefined variable” errors.

pub fn with_schema(schema: DataFrameSchema) -> Self

Create a new compiler with a data schema for column resolution. This enables optimized GetDataField/GetDataRow opcodes.

pub fn set_schema(&mut self, schema: DataFrameSchema)

Set the data schema for column resolution. Must be called before compiling data access expressions.

pub fn set_source_dir(&mut self, dir: PathBuf)

Set the source directory for resolving relative source file paths.

pub fn with_extensions(self, extensions: Vec<ModuleExports>) -> Self

Set extension modules for comptime execution.

pub fn set_type_diagnostic_mode(&mut self, mode: TypeDiagnosticMode)

Configure how shared analyzer diagnostics are emitted.

pub fn set_compile_diagnostic_mode(&mut self, mode: CompileDiagnosticMode)

Configure expression-compilation error recovery behavior.

pub fn set_permission_set(&mut self, permissions: Option<PermissionSet>)

Set the active permission set for compile-time capability checking.

When set, imports that require permissions not in this set will produce compile errors. Pass None to disable checking (default).

impl BytecodeCompiler

pub fn compile(self, program: &Program) -> Result<BytecodeProgram>

Compile a program to bytecode

pub fn compile_with_source( self, program: &Program, source: &str, ) -> Result<BytecodeProgram>

Compile a program to bytecode with source text for error messages

pub fn compile_module_ast( module_ast: &Program, ) -> Result<(BytecodeProgram, HashMap<String, usize>)>

Compile an imported module’s AST to a standalone BytecodeProgram.

This takes the Module’s AST (Program), compiles all exported functions to bytecode, and returns the compiled program along with a mapping of exported function names to their function indices in the compiled output.

The returned BytecodeProgram and function name mapping allow the import handler to resolve imported function calls to the correct bytecode indices.

Currently handles function exports only. Types and values can be added later.

Trait Implementations

impl Default for BytecodeCompiler

fn default() -> Self

Returns the “default value” for a type.