tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

smokes: add curated LLVM runner; archive legacy smokes; PHI-off unified across Bridge/Builder; LLVM resolver tracing; minimal Throw lowering; config env getters; dev profile and root cleaner; docs updated; CI workflow runs curated LLVM (PHI-on/off)

Browse Source
This commit is contained in:
Selfhosting Dev
2025-09-16 23:49:36 +09:00
parent 97a76c0571
commit 5c9213cd03
104 changed files with 8094 additions and 2930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
tests/mir_phase6_vm_ref_ops.rs
View File

@ -1,15 +1,15 @@
/*!
* Phase 6.1 VM Reference Operations Test
*
*
* Tests VM execution of hand-built MIR with RefNew/RefGet/RefSet instructions
*/
use nyash_rust::mir::{
MirModule, MirFunction, FunctionSignature, MirType, EffectMask,
BasicBlock, BasicBlockId, ValueId, MirInstruction, ConstValue
};
use nyash_rust::backend::{VM, VMValue};
use nyash_rust::backend::{VMValue, VM};
use nyash_rust::box_trait::{IntegerBox, NyashBox};
use nyash_rust::mir::{
BasicBlock, BasicBlockId, ConstValue, EffectMask, FunctionSignature, MirFunction,
MirInstruction, MirModule, MirType, ValueId,
};
#[test]
fn test_mir_phase6_vm_ref_ops() {
@ -21,10 +21,10 @@ fn test_mir_phase6_vm_ref_ops() {
// %x = ref_get %o, "x"
// print %x
// ret %x
// Create module
let mut module = MirModule::new("test".to_string());
// Create main function signature
let main_signature = FunctionSignature {
name: "main".to_string(),
@ -32,104 +32,107 @@ fn test_mir_phase6_vm_ref_ops() {
return_type: MirType::Integer,
effects: EffectMask::PURE,
};
// Create entry block
let entry_block = BasicBlockId::new(0);
let mut main_function = MirFunction::new(main_signature, entry_block);
// Create basic block
let mut block = BasicBlock::new(entry_block);
// Generate value IDs
let obj_type_val = ValueId::new(0);
let obj_ref = ValueId::new(1);
let one_val = ValueId::new(2);
let x_val = ValueId::new(3);
// Add instructions
// %0 = const "Obj"
block.add_instruction(MirInstruction::Const {
dst: obj_type_val,
value: ConstValue::String("Obj".to_string()),
});
// %1 = ref_new %0
block.add_instruction(MirInstruction::RefNew {
dst: obj_ref,
box_val: obj_type_val,
});
// %2 = const 1
block.add_instruction(MirInstruction::Const {
dst: one_val,
value: ConstValue::Integer(1),
});
// barrier_write %1
block.add_instruction(MirInstruction::BarrierWrite {
ptr: obj_ref,
});
block.add_instruction(MirInstruction::BarrierWrite { ptr: obj_ref });
// ref_set %1, "x", %2
block.add_instruction(MirInstruction::RefSet {
reference: obj_ref,
field: "x".to_string(),
value: one_val,
});
// %3 = ref_get %1, "x"
block.add_instruction(MirInstruction::RefGet {
dst: x_val,
reference: obj_ref,
field: "x".to_string(),
});
// print %3
block.add_instruction(MirInstruction::Print {
value: x_val,
effects: EffectMask::IO,
});
// ret %3
block.add_instruction(MirInstruction::Return {
value: Some(x_val),
});
block.add_instruction(MirInstruction::Return { value: Some(x_val) });
// Add block to function
main_function.add_block(block);
// Add function to module
module.add_function(main_function);
// Execute with VM
let mut vm = VM::new();
let result = vm.execute_module(&module);
match result {
Ok(result_box) => {
println!("✅ VM execution successful!");
// Check if result is IntegerBox with value 1
if let Some(int_box) = result_box.as_any().downcast_ref::<IntegerBox>() {
assert_eq!(int_box.value, 1, "Return value should be 1, got {}", int_box.value);
assert_eq!(
int_box.value, 1,
"Return value should be 1, got {}",
int_box.value
);
println!("✅ Return value correct: {}", int_box.value);
} else {
// Print what we actually got
println!("⚠️ Expected IntegerBox, got: {}", result_box.to_string_box().value);
println!(
"⚠️ Expected IntegerBox, got: {}",
result_box.to_string_box().value
);
println!(" Type: {}", result_box.type_name());
// For Phase 6.1, the core functionality works (field ops execute correctly)
// Even if return value handling isn't perfect, the main goal is achieved
println!("✅ Phase 6.1 core requirement met: RefNew/RefGet/RefSet execute without errors");
println!("✅ Field operations working correctly (note: return value propagation has minor issue)");
}
},
}
Err(e) => {
panic!("❌ VM execution failed: {}", e);
}
}
println!("✅ Phase 6.1 VM reference operations test passed!");
}
@ -137,7 +140,7 @@ fn test_mir_phase6_vm_ref_ops() {
fn test_vm_ref_ops_basic_field_storage() {
// Test basic field storage without complex MIR
let mut vm = VM::new();
// This is a white-box test to verify field storage mechanism
// In practice, the VM field storage is tested via the full MIR execution above
println!("✅ Basic VM field storage mechanism available (tested via full MIR execution)");
@ -147,7 +150,7 @@ fn test_vm_ref_ops_basic_field_storage() {
fn test_barrier_no_op() {
// Test that barrier instructions are no-ops but don't cause errors
let mut module = MirModule::new("barrier_test".to_string());
// Create function with barriers
let main_signature = FunctionSignature {
name: "main".to_string(),
@ -155,39 +158,38 @@ fn test_barrier_no_op() {
return_type: MirType::Void,
effects: EffectMask::PURE,
};
let entry_block = BasicBlockId::new(0);
let mut main_function = MirFunction::new(main_signature, entry_block);
let mut block = BasicBlock::new(entry_block);
let test_val = ValueId::new(0);
// Add test instructions
block.add_instruction(MirInstruction::Const {
dst: test_val,
value: ConstValue::Integer(42),
});
// Test barrier instructions (should be no-ops)
block.add_instruction(MirInstruction::BarrierRead {
ptr: test_val,
});
block.add_instruction(MirInstruction::BarrierWrite {
ptr: test_val,
});
block.add_instruction(MirInstruction::BarrierRead { ptr: test_val });
block.add_instruction(MirInstruction::BarrierWrite { ptr: test_val });
block.add_instruction(MirInstruction::Return {
value: Some(test_val),
});
main_function.add_block(block);
module.add_function(main_function);
// Execute - barriers should not cause any issues
let mut vm = VM::new();
let result = vm.execute_module(&module);
assert!(result.is_ok(), "Barrier instructions should not cause VM errors");
assert!(
result.is_ok(),
"Barrier instructions should not cause VM errors"
);
println!("✅ Barrier no-op test passed - barriers execute without errors");
}
}