let mut reporter = DiagnosticReporter::new();

let tokens = lex(source, &mut reporter).expect("lexing should succeed");

let program = parse(&tokens, &mut reporter).expect("parsing should succeed");

let checked = analyze(program, &mut reporter).expect("semantic should succeed");

let res = lower(&checked.program, "test_module");

let mut module = res.module;

let mut ctx = OptimizationContext::new();

ctx.level = OptimizationLevel::O2;

let _opt_res = optimize(&mut module, &ctx);

compile(&module)

let source = r#"

let bc_module = compile_source(source);

// The validator should pass successfully

let validator = BytecodeValidator::new();

let val_res = validator.validate(&bc_module);

assert!(val_res.is_ok(), "Validation failed: {:?}", val_res.err());

let source = r#"

let bc_module = compile_source(source);

let main = &bc_module.functions[0];

// The constant pool should have exactly one instance of "hello" (and possibly Null/None placeholders)

let hello_count = main

.chunk

.constants

.constants

.iter()

.filter(|c| {

if let techscript_ast::LiteralVal::Str(s) = c {

s == "hello"

} else {

false

}

})

.count();

assert_eq!(hello_count, 1, "Constant pool did not deduplicate strings!");

let source = r#"

let bc_module = compile_source(source);

let serialized = BytecodeSerializer::serialize(&bc_module).expect("Serialization failed");

assert!(!serialized.is_empty());

let deserialized =

BytecodeSerializer::deserialize(&serialized).expect("Deserialization failed");

assert_eq!(bc_module.name, deserialized.name);

assert_eq!(bc_module.functions.len(), deserialized.functions.len());

assert_eq!(bc_module.functions[0].name, deserialized.functions[0].name);

let source = r#"

let bc_module = compile_source(source);

let dis = BytecodeDisassembler::disassemble_module(&bc_module);

assert!(!dis.is_empty());

assert!(dis.contains("Function: f"));

assert!(dis.contains("Return"));