Add experimental JoinIR runner and tests
This commit is contained in:
nyash-codex
327
src/mir/join_ir_runner.rs
Normal file
327
src/mir/join_ir_runner.rs
Normal file
@ -0,0 +1,327 @@
|
||||
//! JoinIR 実験用のミニ実行器（Phase 27.2）
|
||||
//!
|
||||
//! 目的: hand-written / minimal JoinIR を VM と A/B 比較するための軽量ランナー。
|
||||
//! - 対応値: i64 / bool / String / Unit
|
||||
//! - 対応命令: Const / BinOp / Compare / BoxCall(StringBox: length, substring) /
|
||||
//! Call / Jump / Ret
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::mir::join_ir::{
|
||||
BinOpKind, CompareOp, ConstValue, JoinFuncId, JoinInst, JoinModule, MirLikeInst, VarId,
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum JoinValue {
|
||||
Int(i64),
|
||||
Bool(bool),
|
||||
Str(String),
|
||||
Unit,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct JoinRuntimeError {
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
impl JoinRuntimeError {
|
||||
fn new(msg: impl Into<String>) -> Self {
|
||||
Self {
|
||||
message: msg.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for JoinRuntimeError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{}", self.message)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for JoinRuntimeError {}
|
||||
|
||||
pub fn run_joinir_function(
|
||||
module: &JoinModule,
|
||||
entry: JoinFuncId,
|
||||
args: &[JoinValue],
|
||||
) -> Result<JoinValue, JoinRuntimeError> {
|
||||
execute_function(module, entry, args.to_vec())
|
||||
}
|
||||
|
||||
fn execute_function(
|
||||
module: &JoinModule,
|
||||
mut current_func: JoinFuncId,
|
||||
mut current_args: Vec<JoinValue>,
|
||||
) -> Result<JoinValue, JoinRuntimeError> {
|
||||
'exec: loop {
|
||||
let func = module
|
||||
.functions
|
||||
.get(¤t_func)
|
||||
.ok_or_else(|| JoinRuntimeError::new(format!("Function {:?} not found", current_func)))?;
|
||||
|
||||
if func.params.len() != current_args.len() {
|
||||
return Err(JoinRuntimeError::new(format!(
|
||||
"Arity mismatch for {:?}: expected {}, got {}",
|
||||
func.id,
|
||||
func.params.len(),
|
||||
current_args.len()
|
||||
)));
|
||||
}
|
||||
|
||||
let mut locals: HashMap<VarId, JoinValue> = HashMap::new();
|
||||
for (param, arg) in func.params.iter().zip(current_args.iter()) {
|
||||
locals.insert(*param, arg.clone());
|
||||
}
|
||||
|
||||
let mut ip = 0usize;
|
||||
while ip < func.body.len() {
|
||||
match &func.body[ip] {
|
||||
JoinInst::Compute(inst) => {
|
||||
eval_compute(inst, &mut locals)?;
|
||||
ip += 1;
|
||||
}
|
||||
JoinInst::Call {
|
||||
func: target,
|
||||
args,
|
||||
k_next,
|
||||
dst,
|
||||
} => {
|
||||
if k_next.is_some() {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"Join continuation (k_next) is not supported in the experimental runner",
|
||||
));
|
||||
}
|
||||
let resolved_args = materialize_args(args, &locals)?;
|
||||
if let Some(dst_var) = dst {
|
||||
let value = execute_function(module, *target, resolved_args)?;
|
||||
locals.insert(*dst_var, value);
|
||||
ip += 1;
|
||||
} else {
|
||||
current_func = *target;
|
||||
current_args = resolved_args;
|
||||
continue 'exec;
|
||||
}
|
||||
}
|
||||
JoinInst::Jump { cont: _, args, cond } => {
|
||||
let should_jump = match cond {
|
||||
Some(var) => as_bool(&read_var(&locals, *var)?)?,
|
||||
None => true,
|
||||
};
|
||||
if should_jump {
|
||||
let ret = if let Some(first) = args.first() {
|
||||
read_var(&locals, *first)?
|
||||
} else {
|
||||
JoinValue::Unit
|
||||
};
|
||||
return Ok(ret);
|
||||
}
|
||||
ip += 1;
|
||||
}
|
||||
JoinInst::Ret { value } => {
|
||||
let ret = match value {
|
||||
Some(var) => read_var(&locals, *var)?,
|
||||
None => JoinValue::Unit,
|
||||
};
|
||||
return Ok(ret);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// fallthrough without explicit return
|
||||
return Ok(JoinValue::Unit);
|
||||
}
|
||||
}
|
||||
|
||||
fn eval_compute(inst: &MirLikeInst, locals: &mut HashMap<VarId, JoinValue>) -> Result<(), JoinRuntimeError> {
|
||||
match inst {
|
||||
MirLikeInst::Const { dst, value } => {
|
||||
let v = match value {
|
||||
ConstValue::Integer(i) => JoinValue::Int(*i),
|
||||
ConstValue::Bool(b) => JoinValue::Bool(*b),
|
||||
ConstValue::String(s) => JoinValue::Str(s.clone()),
|
||||
ConstValue::Null => JoinValue::Unit,
|
||||
};
|
||||
locals.insert(*dst, v);
|
||||
}
|
||||
MirLikeInst::BinOp { dst, op, lhs, rhs } => {
|
||||
let l = read_var(locals, *lhs)?;
|
||||
let r = read_var(locals, *rhs)?;
|
||||
let v = match op {
|
||||
BinOpKind::Add => match (l, r) {
|
||||
(JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a + b),
|
||||
(JoinValue::Str(a), JoinValue::Str(b)) => JoinValue::Str(format!("{a}{b}")),
|
||||
_ => {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"Add supported only for (int,int) or (str,str)",
|
||||
))
|
||||
}
|
||||
},
|
||||
BinOpKind::Sub => match (l, r) {
|
||||
(JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a - b),
|
||||
_ => return Err(JoinRuntimeError::new("Sub supported only for integers")),
|
||||
},
|
||||
BinOpKind::Mul => match (l, r) {
|
||||
(JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a * b),
|
||||
_ => return Err(JoinRuntimeError::new("Mul supported only for integers")),
|
||||
},
|
||||
BinOpKind::Div => match (l, r) {
|
||||
(JoinValue::Int(_), JoinValue::Int(0)) => {
|
||||
return Err(JoinRuntimeError::new("Division by zero"))
|
||||
}
|
||||
(JoinValue::Int(a), JoinValue::Int(b)) => JoinValue::Int(a / b),
|
||||
_ => return Err(JoinRuntimeError::new("Div supported only for integers")),
|
||||
},
|
||||
BinOpKind::Or => match (l, r) {
|
||||
(JoinValue::Bool(a), JoinValue::Bool(b)) => JoinValue::Bool(a || b),
|
||||
_ => return Err(JoinRuntimeError::new("Or supported only for bools")),
|
||||
},
|
||||
BinOpKind::And => match (l, r) {
|
||||
(JoinValue::Bool(a), JoinValue::Bool(b)) => JoinValue::Bool(a && b),
|
||||
_ => return Err(JoinRuntimeError::new("And supported only for bools")),
|
||||
},
|
||||
};
|
||||
locals.insert(*dst, v);
|
||||
}
|
||||
MirLikeInst::Compare { dst, op, lhs, rhs } => {
|
||||
let l = read_var(locals, *lhs)?;
|
||||
let r = read_var(locals, *rhs)?;
|
||||
let v = match (l, r) {
|
||||
(JoinValue::Int(a), JoinValue::Int(b)) => match op {
|
||||
CompareOp::Lt => a < b,
|
||||
CompareOp::Le => a <= b,
|
||||
CompareOp::Gt => a > b,
|
||||
CompareOp::Ge => a >= b,
|
||||
CompareOp::Eq => a == b,
|
||||
CompareOp::Ne => a != b,
|
||||
},
|
||||
(JoinValue::Bool(a), JoinValue::Bool(b)) => match op {
|
||||
CompareOp::Eq => a == b,
|
||||
CompareOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"Bool comparison only supports Eq/Ne in the JoinIR runner",
|
||||
))
|
||||
}
|
||||
},
|
||||
(JoinValue::Str(a), JoinValue::Str(b)) => match op {
|
||||
CompareOp::Eq => a == b,
|
||||
CompareOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"String comparison only supports Eq/Ne in the JoinIR runner",
|
||||
))
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"Type mismatch in Compare (expected homogeneous operands)",
|
||||
))
|
||||
}
|
||||
};
|
||||
locals.insert(*dst, JoinValue::Bool(v));
|
||||
}
|
||||
MirLikeInst::BoxCall {
|
||||
dst,
|
||||
box_name,
|
||||
method,
|
||||
args,
|
||||
} => {
|
||||
if box_name != "StringBox" {
|
||||
return Err(JoinRuntimeError::new(format!(
|
||||
"Unsupported box call target: {}",
|
||||
box_name
|
||||
)));
|
||||
}
|
||||
match method.as_str() {
|
||||
"length" => {
|
||||
let arg = expect_str(&read_var(locals, args[0])?)?;
|
||||
locals.insert(*dst.as_ref().ok_or_else(|| {
|
||||
JoinRuntimeError::new("length call requires destination")
|
||||
})?, JoinValue::Int(arg.len() as i64));
|
||||
}
|
||||
"substring" => {
|
||||
if args.len() != 3 {
|
||||
return Err(JoinRuntimeError::new(
|
||||
"substring expects 3 arguments (s, start, end)",
|
||||
));
|
||||
}
|
||||
let s = expect_str(&read_var(locals, args[0])?)?;
|
||||
let start = expect_int(&read_var(locals, args[1])?)?;
|
||||
let end = expect_int(&read_var(locals, args[2])?)?;
|
||||
let slice = safe_substring(&s, start, end)?;
|
||||
let dst_var = dst.ok_or_else(|| {
|
||||
JoinRuntimeError::new("substring call requires destination")
|
||||
})?;
|
||||
locals.insert(dst_var, JoinValue::Str(slice));
|
||||
}
|
||||
_ => {
|
||||
return Err(JoinRuntimeError::new(format!(
|
||||
"Unsupported StringBox method: {}",
|
||||
method
|
||||
)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn safe_substring(s: &str, start: i64, end: i64) -> Result<String, JoinRuntimeError> {
|
||||
if start < 0 || end < 0 {
|
||||
return Err(JoinRuntimeError::new("substring indices must be non-negative"));
|
||||
}
|
||||
let (start_usize, end_usize) = (start as usize, end as usize);
|
||||
if start_usize > end_usize {
|
||||
return Err(JoinRuntimeError::new("substring start > end"));
|
||||
}
|
||||
if start_usize > s.len() || end_usize > s.len() {
|
||||
return Err(JoinRuntimeError::new("substring indices out of bounds"));
|
||||
}
|
||||
Ok(s[start_usize..end_usize].to_string())
|
||||
}
|
||||
|
||||
fn read_var(locals: &HashMap<VarId, JoinValue>, var: VarId) -> Result<JoinValue, JoinRuntimeError> {
|
||||
locals
|
||||
.get(&var)
|
||||
.cloned()
|
||||
.ok_or_else(|| JoinRuntimeError::new(format!("Variable {:?} not bound", var)))
|
||||
}
|
||||
|
||||
fn materialize_args(
|
||||
args: &[VarId],
|
||||
locals: &HashMap<VarId, JoinValue>,
|
||||
) -> Result<Vec<JoinValue>, JoinRuntimeError> {
|
||||
args.iter().map(|v| read_var(locals, *v)).collect()
|
||||
}
|
||||
|
||||
fn as_bool(value: &JoinValue) -> Result<bool, JoinRuntimeError> {
|
||||
match value {
|
||||
JoinValue::Bool(b) => Ok(*b),
|
||||
JoinValue::Int(i) => Ok(*i != 0),
|
||||
JoinValue::Unit => Ok(false),
|
||||
other => Err(JoinRuntimeError::new(format!(
|
||||
"Expected bool-compatible value, got {:?}",
|
||||
other
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
fn expect_int(value: &JoinValue) -> Result<i64, JoinRuntimeError> {
|
||||
match value {
|
||||
JoinValue::Int(i) => Ok(*i),
|
||||
other => Err(JoinRuntimeError::new(format!(
|
||||
"Expected int, got {:?}",
|
||||
other
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
fn expect_str(value: &JoinValue) -> Result<String, JoinRuntimeError> {
|
||||
match value {
|
||||
JoinValue::Str(s) => Ok(s.clone()),
|
||||
other => Err(JoinRuntimeError::new(format!(
|
||||
"Expected string, got {:?}",
|
||||
other
|
||||
))),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user