Crate fusabi_frontend

Crate fusabi_frontend 

Source
Expand description

Fusabi Frontend - Parser, Typechecker, and Bytecode Compiler

This crate implements the frontend of the Fusabi (F# Script Runtime System), responsible for parsing F# source code into an AST, performing type checking, and compiling to bytecode for the Fusabi VM.

§Modules

  • ast: Core AST (Abstract Syntax Tree) definitions
  • lexer: Lexer/Tokenizer for Mini-F# source code
  • parser: Recursive-descent parser for Mini-F# expressions
  • compiler: Bytecode compiler (AST → Bytecode)
  • types: Type system infrastructure for Hindley-Milner type inference
  • inference: Type inference engine (Hindley-Milner algorithm)
  • typed_ast: Optional typed AST with type annotations
  • span: Source location tracking for error reporting
  • error: Error types with beautiful formatting and suggestions
  • modules: Module system for code organization

§Example

use fusabi_frontend::ast::{Expr, Literal, BinOp};
use fusabi_frontend::lexer::Lexer;
use fusabi_frontend::parser::Parser;
use fusabi_frontend::compiler::{Compiler, CompileOptions};
use fusabi_frontend::inference::TypeInference;
use fusabi_frontend::types::TypeEnv;

// Full pipeline: source -> tokens -> AST -> type check -> bytecode
let source = "let x = 42 in x + 1";
let mut lexer = Lexer::new(source);
let tokens = lexer.tokenize().unwrap();
let mut parser = Parser::new(tokens);
let ast = parser.parse().unwrap();

// Type check
let mut infer = TypeInference::new();
let env = TypeEnv::new();
let ty = infer.infer_and_solve(&ast, &env).unwrap();

// Compile without type checking (backward compatible)
let chunk = Compiler::compile(&ast).unwrap();

// Or compile with type checking enabled
let options = CompileOptions {
    enable_type_checking: true,
    ..Default::default()
};
let chunk_checked = Compiler::compile_with_options(&ast, options).unwrap();

// Chunk is ready for VM execution
assert!(chunk.instructions.len() > 0);

Re-exports§

pub use ast::BinOp;
pub use ast::Expr;
pub use ast::Literal;
pub use ast::LoadDirective;
pub use ast::ModuleDef;
pub use ast::ModuleItem;
pub use ast::Pattern;
pub use ast::Program;
pub use compiler::CompileError;
pub use compiler::CompileOptions;
pub use compiler::Compiler;
pub use error::TypeError;
pub use error::TypeErrorKind;
pub use inference::TypeInference;
pub use lexer::LexError;
pub use lexer::Lexer;
pub use lexer::Position;
pub use lexer::Token;
pub use lexer::TokenWithPos;
pub use loader::FileLoader;
pub use loader::LoadError;
pub use loader::LoadedFile;
pub use modules::Module;
pub use modules::ModulePath;
pub use modules::ModuleRegistry;
pub use modules::TypeDefinition as ModuleTypeDef;
pub use parser::ParseError;
pub use parser::Parser;
pub use span::Span;
pub use typed_ast::TypedExpr;
pub use typed_ast::TypedPattern;
pub use types::Substitution;
pub use types::Type;
pub use types::TypeEnv;
pub use types::TypeScheme;
pub use types::TypeVar;

Modules§

ast
Core AST (Abstract Syntax Tree) definitions for Fusabi Mini-F#.
compiler
Bytecode Compiler for Fusabi Mini-F#
error
Error reporting for type checking and compilation.
inference
Hindley-Milner Type Inference (Algorithm W)
lexer
Lexer/Tokenizer for Mini-F# source code.
loader
File loader for multi-file module system
modules
Module System for Fusabi Mini-F#
parser
Recursive-descent parser for Mini-F# expressions.
span
Source location tracking for error reporting.
typed_ast
Typed AST - Optional type-annotated AST representation
types
Type System Infrastructure for Fusabi

Enums§

CompilationError
Unified error type for the compilation pipeline

Functions§

compile_program_from_source
Convenience function to compile a program from source code