1607 lines
60 KiB
Rust
1607 lines
60 KiB
Rust
use crate::mir::{
|
||
BasicBlockId, BinaryOp, ConstValue, EffectMask, FunctionSignature, MirFunction, MirInstruction,
|
||
MirModule, MirPrinter, MirType, ValueId,
|
||
};
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
#[derive(Debug, Deserialize, Serialize)]
|
||
struct ProgramV0 {
|
||
version: i32,
|
||
kind: String,
|
||
body: Vec<StmtV0>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, Serialize, Clone)]
|
||
#[serde(tag = "type")]
|
||
enum StmtV0 {
|
||
Return {
|
||
expr: ExprV0,
|
||
},
|
||
Extern {
|
||
iface: String,
|
||
method: String,
|
||
args: Vec<ExprV0>,
|
||
},
|
||
// Optional: expression statement (side effects only)
|
||
Expr {
|
||
expr: ExprV0,
|
||
},
|
||
// Optional: local binding (Stage-2)
|
||
Local {
|
||
name: String,
|
||
expr: ExprV0,
|
||
},
|
||
// Optional: if/else (Stage-2)
|
||
If {
|
||
cond: ExprV0,
|
||
then: Vec<StmtV0>,
|
||
#[serde(rename = "else", default)]
|
||
r#else: Option<Vec<StmtV0>>,
|
||
},
|
||
// Optional: loop (Stage-2)
|
||
Loop {
|
||
cond: ExprV0,
|
||
body: Vec<StmtV0>,
|
||
},
|
||
Break,
|
||
Continue,
|
||
Try {
|
||
#[serde(rename = "try")]
|
||
try_body: Vec<StmtV0>,
|
||
#[serde(default)]
|
||
catches: Vec<CatchV0>,
|
||
#[serde(default)]
|
||
finally: Vec<StmtV0>,
|
||
},
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
|
||
struct CatchV0 {
|
||
#[serde(rename = "param", default)]
|
||
param: Option<String>,
|
||
#[serde(rename = "typeHint", default)]
|
||
type_hint: Option<String>,
|
||
#[serde(default)]
|
||
body: Vec<StmtV0>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, Serialize, Clone)]
|
||
#[serde(tag = "type")]
|
||
enum ExprV0 {
|
||
Int {
|
||
value: serde_json::Value,
|
||
},
|
||
Str {
|
||
value: String,
|
||
},
|
||
Bool {
|
||
value: bool,
|
||
},
|
||
Binary {
|
||
op: String,
|
||
lhs: Box<ExprV0>,
|
||
rhs: Box<ExprV0>,
|
||
},
|
||
Extern {
|
||
iface: String,
|
||
method: String,
|
||
args: Vec<ExprV0>,
|
||
},
|
||
Compare {
|
||
op: String,
|
||
lhs: Box<ExprV0>,
|
||
rhs: Box<ExprV0>,
|
||
},
|
||
Logical {
|
||
op: String,
|
||
lhs: Box<ExprV0>,
|
||
rhs: Box<ExprV0>,
|
||
}, // short-circuit: &&, || (or: "and"/"or")
|
||
// Stage-2 additions (optional):
|
||
Call {
|
||
name: String,
|
||
args: Vec<ExprV0>,
|
||
},
|
||
Method {
|
||
recv: Box<ExprV0>,
|
||
method: String,
|
||
args: Vec<ExprV0>,
|
||
},
|
||
New {
|
||
class: String,
|
||
args: Vec<ExprV0>,
|
||
},
|
||
Var {
|
||
name: String,
|
||
},
|
||
Throw {
|
||
expr: Box<ExprV0>,
|
||
},
|
||
}
|
||
|
||
#[derive(Clone, Copy)]
|
||
struct LoopContext {
|
||
cond_bb: BasicBlockId,
|
||
exit_bb: BasicBlockId,
|
||
}
|
||
|
||
fn lower_throw(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
exception_value: ValueId,
|
||
) -> (ValueId, BasicBlockId) {
|
||
if std::env::var("NYASH_BRIDGE_THROW_ENABLE").ok().as_deref() == Some("1") {
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.set_terminator(MirInstruction::Throw {
|
||
exception: exception_value,
|
||
effects: EffectMask::PANIC,
|
||
});
|
||
}
|
||
(exception_value, cur_bb)
|
||
} else {
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst,
|
||
value: ConstValue::Integer(0),
|
||
});
|
||
}
|
||
(dst, cur_bb)
|
||
}
|
||
}
|
||
|
||
pub fn parse_json_v0_to_module(json: &str) -> Result<MirModule, String> {
|
||
let prog: ProgramV0 =
|
||
serde_json::from_str(json).map_err(|e| format!("invalid JSON v0: {}", e))?;
|
||
if prog.version != 0 || prog.kind != "Program" {
|
||
return Err("unsupported IR: expected {version:0, kind:\"Program\"}".into());
|
||
}
|
||
// Create module and main function
|
||
let mut module = MirModule::new("ny_json_v0".into());
|
||
let sig = FunctionSignature {
|
||
name: "main".into(),
|
||
params: vec![],
|
||
return_type: MirType::Integer,
|
||
effects: EffectMask::PURE,
|
||
};
|
||
let entry = BasicBlockId::new(0);
|
||
let mut f = MirFunction::new(sig, entry);
|
||
|
||
if prog.body.is_empty() {
|
||
return Err("empty body".into());
|
||
}
|
||
|
||
// Variable map for simple locals (Stage-2; currently minimal)
|
||
let mut var_map: std::collections::HashMap<String, crate::mir::ValueId> =
|
||
std::collections::HashMap::new();
|
||
let mut loop_stack: Vec<LoopContext> = Vec::new();
|
||
let start_bb = f.entry_block;
|
||
let end_bb =
|
||
lower_stmt_list_with_vars(&mut f, start_bb, &prog.body, &mut var_map, &mut loop_stack)?;
|
||
// Ensure function terminates: add `ret 0` to last un-terminated block (prefer end_bb else entry)
|
||
let need_default_ret = f.blocks.iter().any(|(_k, b)| !b.is_terminated());
|
||
if need_default_ret {
|
||
let target_bb = end_bb;
|
||
let dst_id = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(target_bb) {
|
||
if !bb.is_terminated() {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst: dst_id,
|
||
value: ConstValue::Integer(0),
|
||
});
|
||
bb.set_terminator(MirInstruction::Return {
|
||
value: Some(dst_id),
|
||
});
|
||
}
|
||
}
|
||
}
|
||
// Keep return type unknown to allow dynamic display (VM/Interpreter)
|
||
f.signature.return_type = MirType::Unknown;
|
||
module.add_function(f);
|
||
Ok(module)
|
||
}
|
||
|
||
fn next_block_id(f: &MirFunction) -> BasicBlockId {
|
||
let mut mx = 0u32;
|
||
for k in f.blocks.keys() {
|
||
if k.0 >= mx {
|
||
mx = k.0 + 1;
|
||
}
|
||
}
|
||
BasicBlockId::new(mx)
|
||
}
|
||
|
||
fn lower_expr(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
e: &ExprV0,
|
||
) -> Result<(crate::mir::ValueId, BasicBlockId), String> {
|
||
match e {
|
||
ExprV0::Int { value } => {
|
||
// Accept number or stringified digits
|
||
let ival: i64 = if let Some(n) = value.as_i64() {
|
||
n
|
||
} else if let Some(s) = value.as_str() {
|
||
s.parse().map_err(|_| "invalid int literal")?
|
||
} else {
|
||
return Err("invalid int literal".into());
|
||
};
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst,
|
||
value: ConstValue::Integer(ival),
|
||
});
|
||
}
|
||
Ok((dst, cur_bb))
|
||
}
|
||
ExprV0::Str { value } => {
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst,
|
||
value: ConstValue::String(value.clone()),
|
||
});
|
||
}
|
||
Ok((dst, cur_bb))
|
||
}
|
||
ExprV0::Bool { value } => {
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst,
|
||
value: ConstValue::Bool(*value),
|
||
});
|
||
}
|
||
Ok((dst, cur_bb))
|
||
}
|
||
ExprV0::Binary { op, lhs, rhs } => {
|
||
let (l, cur_after_l) = lower_expr(f, cur_bb, lhs)?;
|
||
let (r, cur_after_r) = lower_expr(f, cur_after_l, rhs)?;
|
||
let bop = match op.as_str() {
|
||
"+" => BinaryOp::Add,
|
||
"-" => BinaryOp::Sub,
|
||
"*" => BinaryOp::Mul,
|
||
"/" => BinaryOp::Div,
|
||
_ => return Err("unsupported op".into()),
|
||
};
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_after_r) {
|
||
bb.add_instruction(MirInstruction::BinOp {
|
||
dst,
|
||
op: bop,
|
||
lhs: l,
|
||
rhs: r,
|
||
});
|
||
}
|
||
Ok((dst, cur_after_r))
|
||
}
|
||
ExprV0::Extern {
|
||
iface,
|
||
method,
|
||
args,
|
||
} => {
|
||
let (arg_ids, cur2) = lower_args(f, cur_bb, args)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur2) {
|
||
bb.add_instruction(MirInstruction::ExternCall {
|
||
dst: Some(dst),
|
||
iface_name: iface.clone(),
|
||
method_name: method.clone(),
|
||
args: arg_ids,
|
||
effects: EffectMask::IO,
|
||
});
|
||
}
|
||
Ok((dst, cur2))
|
||
}
|
||
ExprV0::Compare { op, lhs, rhs } => {
|
||
let (l, cur_after_l) = lower_expr(f, cur_bb, lhs)?;
|
||
let (r, cur_after_r) = lower_expr(f, cur_after_l, rhs)?;
|
||
let cop = match op.as_str() {
|
||
"==" => crate::mir::CompareOp::Eq,
|
||
"!=" => crate::mir::CompareOp::Ne,
|
||
"<" => crate::mir::CompareOp::Lt,
|
||
"<=" => crate::mir::CompareOp::Le,
|
||
">" => crate::mir::CompareOp::Gt,
|
||
">=" => crate::mir::CompareOp::Ge,
|
||
_ => return Err("unsupported compare op".into()),
|
||
};
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_after_r) {
|
||
bb.add_instruction(MirInstruction::Compare {
|
||
dst,
|
||
op: cop,
|
||
lhs: l,
|
||
rhs: r,
|
||
});
|
||
}
|
||
Ok((dst, cur_after_r))
|
||
}
|
||
ExprV0::Logical { op, lhs, rhs } => {
|
||
// Short-circuit boolean logic with branches (+phi or edge-copy)
|
||
let (l, cur_after_l) = lower_expr(f, cur_bb, lhs)?;
|
||
let rhs_bb = next_block_id(f);
|
||
let fall_bb = BasicBlockId::new(rhs_bb.0 + 1);
|
||
let merge_bb = BasicBlockId::new(rhs_bb.0 + 2);
|
||
f.add_block(crate::mir::BasicBlock::new(rhs_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(fall_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(merge_bb));
|
||
// Branch depending on op
|
||
let is_and = matches!(op.as_str(), "&&" | "and");
|
||
if let Some(bb) = f.get_block_mut(cur_after_l) {
|
||
if is_and {
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: l,
|
||
then_bb: rhs_bb,
|
||
else_bb: fall_bb,
|
||
});
|
||
} else {
|
||
// OR: if lhs true, go to fall_bb (true path), else evaluate rhs
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: l,
|
||
then_bb: fall_bb,
|
||
else_bb: rhs_bb,
|
||
});
|
||
}
|
||
}
|
||
// Telemetry: note short-circuit lowering
|
||
crate::jit::events::emit_lower(
|
||
serde_json::json!({
|
||
"id": "shortcircuit",
|
||
"op": if is_and { "and" } else { "or" },
|
||
"rhs_bb": rhs_bb.0,
|
||
"fall_bb": fall_bb.0,
|
||
"merge_bb": merge_bb.0
|
||
}),
|
||
"shortcircuit",
|
||
"<json_v0>",
|
||
);
|
||
if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
eprintln!(
|
||
"[bridge/logical] op={} rhs_bb={} fall_bb={} merge_bb={}",
|
||
if is_and { "and" } else { "or" },
|
||
rhs_bb.0,
|
||
fall_bb.0,
|
||
merge_bb.0
|
||
);
|
||
}
|
||
// false/true constant in fall_bb depending on op
|
||
let cdst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(fall_bb) {
|
||
let cval = if is_and {
|
||
ConstValue::Bool(false)
|
||
} else {
|
||
ConstValue::Bool(true)
|
||
};
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst: cdst,
|
||
value: cval,
|
||
});
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
// evaluate rhs starting at rhs_bb and ensure the terminal block jumps to merge
|
||
let (rval, rhs_end) = lower_expr(f, rhs_bb, rhs)?;
|
||
if let Some(bb) = f.get_block_mut(rhs_end) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
}
|
||
if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
eprintln!(
|
||
"[bridge/logical] rhs_end={} jump->merge_bb={}",
|
||
rhs_end.0, merge_bb.0
|
||
);
|
||
}
|
||
// Merge: PHI または edge-copy で合流値を定義
|
||
let no_phi = crate::config::env::mir_no_phi();
|
||
let out = f.next_value_id();
|
||
if no_phi {
|
||
// Edge copies in predecessors
|
||
if let Some(bb) = f.get_block_mut(fall_bb) {
|
||
bb.add_instruction(MirInstruction::Copy { dst: out, src: cdst });
|
||
}
|
||
if let Some(bb) = f.get_block_mut(rhs_end) {
|
||
bb.add_instruction(MirInstruction::Copy { dst: out, src: rval });
|
||
}
|
||
} else if let Some(bb) = f.get_block_mut(merge_bb) {
|
||
let mut inputs: Vec<(BasicBlockId, ValueId)> = vec![(fall_bb, cdst)];
|
||
if rhs_end != fall_bb {
|
||
inputs.push((rhs_end, rval));
|
||
} else {
|
||
// Degenerate case: RHS ended in fall_bb (e.g., constant expression).
|
||
// Reuse the constant to keep PHI well-formed.
|
||
inputs.push((fall_bb, rval));
|
||
}
|
||
inputs.sort_by_key(|(bbid, _)| bbid.0);
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst: out, inputs });
|
||
}
|
||
Ok((out, merge_bb))
|
||
}
|
||
ExprV0::Call { name, args } => {
|
||
// Special: array literal lowering — Call{name:"array.of", args:[...]} → new ArrayBox(); push(...); result=array
|
||
if name == "array.of" {
|
||
// Create array first
|
||
let arr = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst: arr,
|
||
box_type: "ArrayBox".into(),
|
||
args: vec![],
|
||
});
|
||
}
|
||
// For each element: eval then push
|
||
let mut cur = cur_bb;
|
||
for e in args {
|
||
let (v, c) = lower_expr(f, cur, e)?;
|
||
cur = c;
|
||
let tmp = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(tmp),
|
||
box_val: arr,
|
||
method: "push".into(),
|
||
method_id: None,
|
||
args: vec![v],
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
}
|
||
return Ok((arr, cur));
|
||
}
|
||
// Special: map literal lowering — Call{name:"map.of", args:[k1, v1, k2, v2, ...]} → new MapBox(); set(k,v)...; result=map
|
||
if name == "map.of" {
|
||
let mapv = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst: mapv,
|
||
box_type: "MapBox".into(),
|
||
args: vec![],
|
||
});
|
||
}
|
||
let mut cur = cur_bb;
|
||
let mut it = args.iter();
|
||
while let Some(k) = it.next() {
|
||
if let Some(v) = it.next() {
|
||
let (kv, cur2) = lower_expr(f, cur, k)?;
|
||
cur = cur2;
|
||
let (vv, cur3) = lower_expr(f, cur, v)?;
|
||
cur = cur3;
|
||
let tmp = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(tmp),
|
||
box_val: mapv,
|
||
method: "set".into(),
|
||
method_id: None,
|
||
args: vec![kv, vv],
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return Ok((mapv, cur));
|
||
}
|
||
// Fallback: treat as normal dynamic call
|
||
let (arg_ids, cur) = lower_args(f, cur_bb, args)?;
|
||
let fun_val = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst: fun_val,
|
||
value: ConstValue::String(name.clone()),
|
||
});
|
||
}
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::Call {
|
||
dst: Some(dst),
|
||
func: fun_val,
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
Ok((dst, cur))
|
||
}
|
||
ExprV0::Method { recv, method, args } => {
|
||
// Heuristic: new ConsoleBox().println(x) → externcall env.console.log(x)
|
||
let recv_is_console_new =
|
||
matches!(&**recv, ExprV0::New { class, .. } if class == "ConsoleBox");
|
||
if recv_is_console_new && (method == "println" || method == "print" || method == "log")
|
||
{
|
||
let (arg_ids, cur2) = lower_args(f, cur_bb, args)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur2) {
|
||
bb.add_instruction(MirInstruction::ExternCall {
|
||
dst: Some(dst),
|
||
iface_name: "env.console".into(),
|
||
method_name: "log".into(),
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
return Ok((dst, cur2));
|
||
}
|
||
let (recv_v, cur) = lower_expr(f, cur_bb, recv)?;
|
||
let (arg_ids, cur2) = lower_args(f, cur, args)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur2) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(dst),
|
||
box_val: recv_v,
|
||
method: method.clone(),
|
||
method_id: None,
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
Ok((dst, cur2))
|
||
}
|
||
ExprV0::New { class, args } => {
|
||
let (arg_ids, cur) = lower_args(f, cur_bb, args)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst,
|
||
box_type: class.clone(),
|
||
args: arg_ids,
|
||
});
|
||
}
|
||
Ok((dst, cur))
|
||
}
|
||
ExprV0::Var { name } => Err(format!("undefined variable in this context: {}", name)),
|
||
ExprV0::Throw { expr } => {
|
||
let (exc, cur) = lower_expr(f, cur_bb, expr)?;
|
||
let (dst, cur) = lower_throw(f, cur, exc);
|
||
Ok((dst, cur))
|
||
}
|
||
}
|
||
}
|
||
|
||
fn lower_expr_with_vars(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
e: &ExprV0,
|
||
vars: &mut std::collections::HashMap<String, crate::mir::ValueId>,
|
||
) -> Result<(crate::mir::ValueId, BasicBlockId), String> {
|
||
match e {
|
||
ExprV0::Var { name } => {
|
||
if let Some(&vid) = vars.get(name) {
|
||
return Ok((vid, cur_bb));
|
||
}
|
||
if name == "me" {
|
||
// Optional gate: allow a dummy 'me' instance for Stage-2 JSON smoke
|
||
if std::env::var("NYASH_BRIDGE_ME_DUMMY").ok().as_deref() == Some("1") {
|
||
let class = std::env::var("NYASH_BRIDGE_ME_CLASS")
|
||
.unwrap_or_else(|_| "Main".to_string());
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst,
|
||
box_type: class,
|
||
args: vec![],
|
||
});
|
||
}
|
||
vars.insert("me".to_string(), dst);
|
||
return Ok((dst, cur_bb));
|
||
} else {
|
||
return Err("undefined 'me' outside box context (set NYASH_BRIDGE_ME_DUMMY=1 to inject placeholder)".into());
|
||
}
|
||
}
|
||
Err(format!("undefined variable: {}", name))
|
||
}
|
||
ExprV0::Throw { expr } => {
|
||
let (exc, cur) = lower_expr_with_vars(f, cur_bb, expr, vars)?;
|
||
let (dst, cur) = lower_throw(f, cur, exc);
|
||
Ok((dst, cur))
|
||
}
|
||
ExprV0::Call { name, args } => {
|
||
// Special: array literal lowering in vars context
|
||
if name == "array.of" {
|
||
let arr = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst: arr,
|
||
box_type: "ArrayBox".into(),
|
||
args: vec![],
|
||
});
|
||
}
|
||
let mut cur = cur_bb;
|
||
for e in args {
|
||
let (v, c) = lower_expr_with_vars(f, cur, e, vars)?;
|
||
cur = c;
|
||
let tmp = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(tmp),
|
||
box_val: arr,
|
||
method: "push".into(),
|
||
method_id: None,
|
||
args: vec![v],
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
}
|
||
return Ok((arr, cur));
|
||
}
|
||
// Special: map literal lowering in vars context
|
||
if name == "map.of" {
|
||
let mapv = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst: mapv,
|
||
box_type: "MapBox".into(),
|
||
args: vec![],
|
||
});
|
||
}
|
||
let mut cur = cur_bb;
|
||
let mut it = args.iter();
|
||
while let Some(k) = it.next() {
|
||
if let Some(v) = it.next() {
|
||
let (kv, cur2) = lower_expr_with_vars(f, cur, k, vars)?;
|
||
cur = cur2;
|
||
let (vv, cur3) = lower_expr_with_vars(f, cur, v, vars)?;
|
||
cur = cur3;
|
||
let tmp = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(tmp),
|
||
box_val: mapv,
|
||
method: "set".into(),
|
||
method_id: None,
|
||
args: vec![kv, vv],
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return Ok((mapv, cur));
|
||
}
|
||
// Lower args
|
||
let (arg_ids, cur) = lower_args_with_vars(f, cur_bb, args, vars)?;
|
||
// Encode as: const fun_name; call
|
||
let fun_val = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst: fun_val,
|
||
value: ConstValue::String(name.clone()),
|
||
});
|
||
}
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::Call {
|
||
dst: Some(dst),
|
||
func: fun_val,
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
Ok((dst, cur))
|
||
}
|
||
ExprV0::Method { recv, method, args } => {
|
||
let recv_is_console_new =
|
||
matches!(&**recv, ExprV0::New { class, .. } if class == "ConsoleBox");
|
||
if recv_is_console_new && (method == "println" || method == "print" || method == "log")
|
||
{
|
||
let (arg_ids, cur2) = lower_args_with_vars(f, cur_bb, args, vars)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur2) {
|
||
bb.add_instruction(MirInstruction::ExternCall {
|
||
dst: Some(dst),
|
||
iface_name: "env.console".into(),
|
||
method_name: "log".into(),
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
return Ok((dst, cur2));
|
||
}
|
||
let (recv_v, cur) = lower_expr_with_vars(f, cur_bb, recv, vars)?;
|
||
let (arg_ids, cur2) = lower_args_with_vars(f, cur, args, vars)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur2) {
|
||
bb.add_instruction(MirInstruction::BoxCall {
|
||
dst: Some(dst),
|
||
box_val: recv_v,
|
||
method: method.clone(),
|
||
method_id: None,
|
||
args: arg_ids,
|
||
effects: EffectMask::READ,
|
||
});
|
||
}
|
||
Ok((dst, cur2))
|
||
}
|
||
ExprV0::New { class, args } => {
|
||
let (arg_ids, cur) = lower_args_with_vars(f, cur_bb, args, vars)?;
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::NewBox {
|
||
dst,
|
||
box_type: class.clone(),
|
||
args: arg_ids,
|
||
});
|
||
}
|
||
Ok((dst, cur))
|
||
}
|
||
ExprV0::Binary { op, lhs, rhs } => {
|
||
let (l, cur_after_l) = lower_expr_with_vars(f, cur_bb, lhs, vars)?;
|
||
let (r, cur_after_r) = lower_expr_with_vars(f, cur_after_l, rhs, vars)?;
|
||
let bop = match op.as_str() {
|
||
"+" => BinaryOp::Add,
|
||
"-" => BinaryOp::Sub,
|
||
"*" => BinaryOp::Mul,
|
||
"/" => BinaryOp::Div,
|
||
_ => return Err("unsupported op".into()),
|
||
};
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_after_r) {
|
||
bb.add_instruction(MirInstruction::BinOp {
|
||
dst,
|
||
op: bop,
|
||
lhs: l,
|
||
rhs: r,
|
||
});
|
||
}
|
||
Ok((dst, cur_after_r))
|
||
}
|
||
ExprV0::Compare { op, lhs, rhs } => {
|
||
let (l, cur_after_l) = lower_expr_with_vars(f, cur_bb, lhs, vars)?;
|
||
let (r, cur_after_r) = lower_expr_with_vars(f, cur_after_l, rhs, vars)?;
|
||
let cop = match op.as_str() {
|
||
"==" => crate::mir::CompareOp::Eq,
|
||
"!=" => crate::mir::CompareOp::Ne,
|
||
"<" => crate::mir::CompareOp::Lt,
|
||
"<=" => crate::mir::CompareOp::Le,
|
||
">" => crate::mir::CompareOp::Gt,
|
||
">=" => crate::mir::CompareOp::Ge,
|
||
_ => return Err("unsupported compare op".into()),
|
||
};
|
||
let dst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_after_r) {
|
||
bb.add_instruction(MirInstruction::Compare {
|
||
dst,
|
||
op: cop,
|
||
lhs: l,
|
||
rhs: r,
|
||
});
|
||
}
|
||
Ok((dst, cur_after_r))
|
||
}
|
||
ExprV0::Logical { op, lhs, rhs } => {
|
||
let (l, cur_after_l) = lower_expr_with_vars(f, cur_bb, lhs, vars)?;
|
||
let rhs_bb = next_block_id(f);
|
||
let fall_bb = BasicBlockId::new(rhs_bb.0 + 1);
|
||
let merge_bb = BasicBlockId::new(rhs_bb.0 + 2);
|
||
f.add_block(crate::mir::BasicBlock::new(rhs_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(fall_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(merge_bb));
|
||
let is_and = matches!(op.as_str(), "&&" | "and");
|
||
if let Some(bb) = f.get_block_mut(cur_after_l) {
|
||
if is_and {
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: l,
|
||
then_bb: rhs_bb,
|
||
else_bb: fall_bb,
|
||
});
|
||
} else {
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: l,
|
||
then_bb: fall_bb,
|
||
else_bb: rhs_bb,
|
||
});
|
||
}
|
||
}
|
||
let cdst = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(fall_bb) {
|
||
let cval = if is_and {
|
||
ConstValue::Bool(false)
|
||
} else {
|
||
ConstValue::Bool(true)
|
||
};
|
||
bb.add_instruction(MirInstruction::Const {
|
||
dst: cdst,
|
||
value: cval,
|
||
});
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
let (rval, rhs_end) = lower_expr_with_vars(f, rhs_bb, rhs, vars)?;
|
||
if let Some(bb) = f.get_block_mut(rhs_end) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
}
|
||
let out = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(merge_bb) {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi {
|
||
dst: out,
|
||
inputs: vec![(rhs_end, rval), (fall_bb, cdst)],
|
||
});
|
||
}
|
||
Ok((out, merge_bb))
|
||
}
|
||
_ => lower_expr(f, cur_bb, e),
|
||
}
|
||
}
|
||
|
||
fn lower_stmt_with_vars(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
s: &StmtV0,
|
||
vars: &mut std::collections::HashMap<String, crate::mir::ValueId>,
|
||
loop_stack: &mut Vec<LoopContext>,
|
||
) -> Result<BasicBlockId, String> {
|
||
match s {
|
||
StmtV0::Return { expr } => {
|
||
let (v, cur) = lower_expr_with_vars(f, cur_bb, expr, vars)?;
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.set_terminator(MirInstruction::Return { value: Some(v) });
|
||
}
|
||
Ok(cur)
|
||
}
|
||
StmtV0::Extern {
|
||
iface,
|
||
method,
|
||
args,
|
||
} => {
|
||
let (arg_ids, cur) = lower_args_with_vars(f, cur_bb, args, vars)?;
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.add_instruction(MirInstruction::ExternCall {
|
||
dst: None,
|
||
iface_name: iface.clone(),
|
||
method_name: method.clone(),
|
||
args: arg_ids,
|
||
effects: EffectMask::IO,
|
||
});
|
||
}
|
||
Ok(cur)
|
||
}
|
||
StmtV0::Expr { expr } => {
|
||
let (_v, cur) = lower_expr_with_vars(f, cur_bb, expr, vars)?;
|
||
Ok(cur)
|
||
}
|
||
StmtV0::Local { name, expr } => {
|
||
let (v, cur) = lower_expr_with_vars(f, cur_bb, expr, vars)?;
|
||
vars.insert(name.clone(), v);
|
||
Ok(cur)
|
||
}
|
||
StmtV0::Break => {
|
||
if let Some(ctx) = loop_stack.last().copied() {
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.set_terminator(MirInstruction::Jump {
|
||
target: ctx.exit_bb,
|
||
});
|
||
}
|
||
crate::jit::events::emit_lower(
|
||
serde_json::json!({
|
||
"id": "loop_break",
|
||
"exit_bb": ctx.exit_bb.0,
|
||
"decision": "lower",
|
||
}),
|
||
"loop",
|
||
"<json_v0>",
|
||
);
|
||
} else if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
eprintln!("[bridge/break] ignoring break outside loop context");
|
||
}
|
||
Ok(cur_bb)
|
||
}
|
||
StmtV0::Continue => {
|
||
if let Some(ctx) = loop_stack.last().copied() {
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.set_terminator(MirInstruction::Jump {
|
||
target: ctx.cond_bb,
|
||
});
|
||
}
|
||
crate::jit::events::emit_lower(
|
||
serde_json::json!({
|
||
"id": "loop_continue",
|
||
"cond_bb": ctx.cond_bb.0,
|
||
"decision": "lower",
|
||
}),
|
||
"loop",
|
||
"<json_v0>",
|
||
);
|
||
} else if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
eprintln!("[bridge/continue] ignoring continue outside loop context");
|
||
}
|
||
Ok(cur_bb)
|
||
}
|
||
StmtV0::Try {
|
||
try_body,
|
||
catches,
|
||
finally,
|
||
} => {
|
||
let try_enabled = std::env::var("NYASH_BRIDGE_TRY_ENABLE").ok().as_deref() == Some("1");
|
||
|
||
if !try_enabled || catches.is_empty() || catches.len() > 1 {
|
||
let mut tmp_vars = vars.clone();
|
||
let mut next_bb =
|
||
lower_stmt_list_with_vars(f, cur_bb, try_body, &mut tmp_vars, loop_stack)?;
|
||
if !finally.is_empty() {
|
||
next_bb =
|
||
lower_stmt_list_with_vars(f, next_bb, finally, &mut tmp_vars, loop_stack)?;
|
||
}
|
||
*vars = tmp_vars;
|
||
return Ok(next_bb);
|
||
}
|
||
|
||
let base_vars = vars.clone();
|
||
let try_bb = next_block_id(f);
|
||
f.add_block(crate::mir::BasicBlock::new(try_bb));
|
||
|
||
let catch_clause = &catches[0];
|
||
let catch_bb = next_block_id(f);
|
||
f.add_block(crate::mir::BasicBlock::new(catch_bb));
|
||
|
||
let finally_bb = if !finally.is_empty() {
|
||
let id = next_block_id(f);
|
||
f.add_block(crate::mir::BasicBlock::new(id));
|
||
Some(id)
|
||
} else {
|
||
None
|
||
};
|
||
|
||
let exit_bb = next_block_id(f);
|
||
f.add_block(crate::mir::BasicBlock::new(exit_bb));
|
||
|
||
let handler_target = finally_bb.unwrap_or(exit_bb);
|
||
|
||
let exception_value = f.next_value_id();
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Catch {
|
||
exception_type: catch_clause.type_hint.clone(),
|
||
exception_value,
|
||
handler_bb: catch_bb,
|
||
});
|
||
bb.set_terminator(MirInstruction::Jump { target: try_bb });
|
||
}
|
||
|
||
let mut try_vars = vars.clone();
|
||
let try_end =
|
||
lower_stmt_list_with_vars(f, try_bb, try_body, &mut try_vars, loop_stack)?;
|
||
if let Some(bb) = f.get_block_mut(try_end) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump {
|
||
target: handler_target,
|
||
});
|
||
}
|
||
}
|
||
let try_branch_vars = try_vars.clone();
|
||
|
||
let mut catch_vars = base_vars.clone();
|
||
if let Some(param) = &catch_clause.param {
|
||
catch_vars.insert(param.clone(), exception_value);
|
||
}
|
||
let catch_end = lower_stmt_list_with_vars(
|
||
f,
|
||
catch_bb,
|
||
&catch_clause.body,
|
||
&mut catch_vars,
|
||
loop_stack,
|
||
)?;
|
||
if let Some(param) = &catch_clause.param {
|
||
catch_vars.remove(param);
|
||
}
|
||
if let Some(bb) = f.get_block_mut(catch_end) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump {
|
||
target: handler_target,
|
||
});
|
||
}
|
||
}
|
||
let catch_branch_vars = catch_vars.clone();
|
||
|
||
use std::collections::HashSet;
|
||
let mut branch_vars = vec![(try_end, try_branch_vars), (catch_end, catch_branch_vars)];
|
||
let merge_target = handler_target;
|
||
|
||
if let Some(finally_block) = finally_bb {
|
||
// ensure finally block exists before inserting phi
|
||
let names: HashSet<String> = {
|
||
let mut set: HashSet<String> = base_vars.keys().cloned().collect();
|
||
for (_, map) in &branch_vars {
|
||
set.extend(map.keys().cloned());
|
||
}
|
||
set
|
||
};
|
||
|
||
let mut merged_vars = base_vars.clone();
|
||
let mut phi_entries: Vec<(ValueId, Vec<(BasicBlockId, ValueId)>)> = Vec::new();
|
||
for name in names {
|
||
let mut inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
|
||
for (bbid, map) in &branch_vars {
|
||
if let Some(&val) = map.get(&name) {
|
||
inputs.push((*bbid, val));
|
||
}
|
||
}
|
||
if inputs.is_empty() {
|
||
if let Some(&base_val) = base_vars.get(&name) {
|
||
merged_vars.insert(name.clone(), base_val);
|
||
}
|
||
continue;
|
||
}
|
||
let unique: HashSet<ValueId> = inputs.iter().map(|(_, v)| *v).collect();
|
||
if unique.len() == 1 {
|
||
merged_vars.insert(name.clone(), inputs[0].1);
|
||
continue;
|
||
}
|
||
let dst = f.next_value_id();
|
||
inputs.sort_by_key(|(bbid, _)| bbid.0);
|
||
phi_entries.push((dst, inputs));
|
||
merged_vars.insert(name.clone(), dst);
|
||
}
|
||
if let Some(bb) = f.get_block_mut(finally_block) {
|
||
for (dst, inputs) in phi_entries {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs });
|
||
}
|
||
}
|
||
|
||
let mut finally_vars = merged_vars.clone();
|
||
let final_end = lower_stmt_list_with_vars(
|
||
f,
|
||
finally_block,
|
||
finally,
|
||
&mut finally_vars,
|
||
loop_stack,
|
||
)?;
|
||
if let Some(bb) = f.get_block_mut(final_end) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: exit_bb });
|
||
}
|
||
}
|
||
*vars = finally_vars;
|
||
Ok(exit_bb)
|
||
} else {
|
||
let names: HashSet<String> = {
|
||
let mut set: HashSet<String> = base_vars.keys().cloned().collect();
|
||
for (_, map) in &branch_vars {
|
||
set.extend(map.keys().cloned());
|
||
}
|
||
set
|
||
};
|
||
|
||
let mut merged_vars = base_vars.clone();
|
||
let mut phi_entries: Vec<(ValueId, Vec<(BasicBlockId, ValueId)>)> = Vec::new();
|
||
for name in names {
|
||
let mut inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
|
||
for (bbid, map) in &branch_vars {
|
||
if let Some(&val) = map.get(&name) {
|
||
inputs.push((*bbid, val));
|
||
}
|
||
}
|
||
if inputs.is_empty() {
|
||
if let Some(&base_val) = base_vars.get(&name) {
|
||
merged_vars.insert(name.clone(), base_val);
|
||
}
|
||
continue;
|
||
}
|
||
let unique: HashSet<ValueId> = inputs.iter().map(|(_, v)| *v).collect();
|
||
if unique.len() == 1 {
|
||
merged_vars.insert(name.clone(), inputs[0].1);
|
||
continue;
|
||
}
|
||
let dst = f.next_value_id();
|
||
inputs.sort_by_key(|(bbid, _)| bbid.0);
|
||
phi_entries.push((dst, inputs));
|
||
merged_vars.insert(name.clone(), dst);
|
||
}
|
||
if let Some(bb) = f.get_block_mut(exit_bb) {
|
||
for (dst, inputs) in phi_entries {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs });
|
||
}
|
||
}
|
||
*vars = merged_vars;
|
||
Ok(exit_bb)
|
||
}
|
||
}
|
||
StmtV0::If { cond, then, r#else } => {
|
||
// Lower condition first
|
||
let (cval, cur) = lower_expr_with_vars(f, cur_bb, cond, vars)?;
|
||
// Create then/else/merge blocks
|
||
let then_bb = next_block_id(f);
|
||
let else_bb = BasicBlockId::new(then_bb.0 + 1);
|
||
let merge_bb = BasicBlockId::new(then_bb.0 + 2);
|
||
f.add_block(crate::mir::BasicBlock::new(then_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(else_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(merge_bb));
|
||
// Branch to then/else
|
||
if let Some(bb) = f.get_block_mut(cur) {
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: cval,
|
||
then_bb,
|
||
else_bb,
|
||
});
|
||
}
|
||
|
||
// Clone current vars as branch-local maps
|
||
let base_vars = vars.clone();
|
||
let mut then_vars = base_vars.clone();
|
||
let tend = lower_stmt_list_with_vars(f, then_bb, then, &mut then_vars, loop_stack)?;
|
||
if let Some(bb) = f.get_block_mut(tend) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
}
|
||
|
||
let (else_end_pred, else_vars) = if let Some(elses) = r#else {
|
||
let mut ev = base_vars.clone();
|
||
let eend = lower_stmt_list_with_vars(f, else_bb, elses, &mut ev, loop_stack)?;
|
||
if let Some(bb) = f.get_block_mut(eend) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
}
|
||
(eend, ev)
|
||
} else {
|
||
// No else: empty path falls through with base vars
|
||
if let Some(bb) = f.get_block_mut(else_bb) {
|
||
bb.set_terminator(MirInstruction::Jump { target: merge_bb });
|
||
}
|
||
(else_bb, base_vars.clone())
|
||
};
|
||
|
||
// Merge at then/else predecessors（PHI or edge-copy）
|
||
use std::collections::HashSet;
|
||
let no_phi = crate::config::env::mir_no_phi();
|
||
let mut names: HashSet<String> = base_vars.keys().cloned().collect();
|
||
for k in then_vars.keys() { names.insert(k.clone()); }
|
||
for k in else_vars.keys() { names.insert(k.clone()); }
|
||
|
||
for name in names {
|
||
let tv = then_vars.get(&name).copied();
|
||
let ev = else_vars.get(&name).copied();
|
||
let exists_base = base_vars.contains_key(&name);
|
||
match (tv, ev, exists_base) {
|
||
(Some(tval), Some(eval), _) => {
|
||
let merged = if tval == eval { tval } else {
|
||
let dst = f.next_value_id();
|
||
if no_phi {
|
||
if let Some(bb) = f.get_block_mut(tend) { bb.add_instruction(MirInstruction::Copy { dst, src: tval }); }
|
||
if let Some(bb) = f.get_block_mut(else_end_pred) { bb.add_instruction(MirInstruction::Copy { dst, src: eval }); }
|
||
} else if let Some(bb) = f.get_block_mut(merge_bb) {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs: vec![(tend, tval), (else_end_pred, eval)] });
|
||
}
|
||
dst
|
||
};
|
||
vars.insert(name, merged);
|
||
}
|
||
(Some(tval), None, true) => {
|
||
if let Some(&bval) = base_vars.get(&name) {
|
||
let merged = if tval == bval { tval } else {
|
||
let dst = f.next_value_id();
|
||
if no_phi {
|
||
if let Some(bb) = f.get_block_mut(tend) { bb.add_instruction(MirInstruction::Copy { dst, src: tval }); }
|
||
if let Some(bb) = f.get_block_mut(else_end_pred) { bb.add_instruction(MirInstruction::Copy { dst, src: bval }); }
|
||
} else if let Some(bb) = f.get_block_mut(merge_bb) {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs: vec![(tend, tval), (else_end_pred, bval)] });
|
||
}
|
||
dst
|
||
};
|
||
vars.insert(name, merged);
|
||
}
|
||
}
|
||
(None, Some(eval), true) => {
|
||
if let Some(&bval) = base_vars.get(&name) {
|
||
let merged = if eval == bval { eval } else {
|
||
let dst = f.next_value_id();
|
||
if no_phi {
|
||
if let Some(bb) = f.get_block_mut(tend) { bb.add_instruction(MirInstruction::Copy { dst, src: bval }); }
|
||
if let Some(bb) = f.get_block_mut(else_end_pred) { bb.add_instruction(MirInstruction::Copy { dst, src: eval }); }
|
||
} else if let Some(bb) = f.get_block_mut(merge_bb) {
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs: vec![(tend, bval), (else_end_pred, eval)] });
|
||
}
|
||
dst
|
||
};
|
||
vars.insert(name, merged);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
Ok(merge_bb)
|
||
}
|
||
StmtV0::Loop { cond, body } => {
|
||
// Create loop blocks
|
||
let cond_bb = next_block_id(f);
|
||
let body_bb = BasicBlockId::new(cond_bb.0 + 1);
|
||
let exit_bb = BasicBlockId::new(cond_bb.0 + 2);
|
||
f.add_block(crate::mir::BasicBlock::new(cond_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(body_bb));
|
||
f.add_block(crate::mir::BasicBlock::new(exit_bb));
|
||
|
||
// Preheader jump into cond
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
if !bb.is_terminated() {
|
||
bb.add_instruction(MirInstruction::Jump { target: cond_bb });
|
||
}
|
||
}
|
||
|
||
// Snapshot base vars and set up merged ids for loop-carried vars
|
||
let no_phi = crate::config::env::mir_no_phi();
|
||
let base_vars = vars.clone();
|
||
let orig_names: Vec<String> = base_vars.keys().cloned().collect();
|
||
let mut phi_map: std::collections::HashMap<String, crate::mir::ValueId> =
|
||
std::collections::HashMap::new();
|
||
for name in &orig_names {
|
||
if let Some(&bval) = base_vars.get(name) {
|
||
let dst = f.next_value_id();
|
||
if no_phi {
|
||
// Preheader edge-copy（cur_bb -> cond）
|
||
if let Some(bb) = f.get_block_mut(cur_bb) {
|
||
bb.add_instruction(MirInstruction::Copy { dst, src: bval });
|
||
}
|
||
} else if let Some(bb) = f.get_block_mut(cond_bb) {
|
||
// Initial incoming from preheader via PHI
|
||
bb.insert_instruction_after_phis(MirInstruction::Phi { dst, inputs: vec![(cur_bb, bval)] });
|
||
}
|
||
phi_map.insert(name.clone(), dst);
|
||
}
|
||
}
|
||
// Redirect current vars to PHIs for use in cond/body
|
||
for (name, &phi) in &phi_map {
|
||
vars.insert(name.clone(), phi);
|
||
}
|
||
|
||
// Lower condition using phi-backed vars
|
||
let (cval, _cend) = lower_expr_with_vars(f, cond_bb, cond, vars)?;
|
||
if let Some(bb) = f.get_block_mut(cond_bb) {
|
||
bb.set_terminator(MirInstruction::Branch {
|
||
condition: cval,
|
||
then_bb: body_bb,
|
||
else_bb: exit_bb,
|
||
});
|
||
}
|
||
|
||
// Lower body; record end block and body-out vars
|
||
let mut body_vars = vars.clone();
|
||
loop_stack.push(LoopContext { cond_bb, exit_bb });
|
||
let bend_res = lower_stmt_list_with_vars(f, body_bb, body, &mut body_vars, loop_stack);
|
||
loop_stack.pop();
|
||
let bend = bend_res?;
|
||
if let Some(bb) = f.get_block_mut(bend) {
|
||
if !bb.is_terminated() {
|
||
bb.set_terminator(MirInstruction::Jump { target: cond_bb });
|
||
}
|
||
}
|
||
|
||
// Wire second incoming from latch (body end)
|
||
let backedge_to_cond = matches!(
|
||
f.blocks.get(&bend).and_then(|bb| bb.terminator.as_ref()),
|
||
Some(MirInstruction::Jump { target, .. }) if *target == cond_bb
|
||
);
|
||
if backedge_to_cond {
|
||
if no_phi {
|
||
// Latch edge-copy（bend -> cond）
|
||
for (name, &phi_dst) in &phi_map {
|
||
if let Some(&latch_val) = body_vars.get(name) {
|
||
if let Some(bb) = f.get_block_mut(bend) {
|
||
bb.add_instruction(MirInstruction::Copy { dst: phi_dst, src: latch_val });
|
||
}
|
||
}
|
||
}
|
||
} else if let Some(bb) = f.get_block_mut(cond_bb) {
|
||
for (name, &phi_dst) in &phi_map {
|
||
if let Some(&latch_val) = body_vars.get(name) {
|
||
for inst in &mut bb.instructions {
|
||
if let MirInstruction::Phi { dst, inputs } = inst {
|
||
if *dst == phi_dst {
|
||
inputs.push((bend, latch_val));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
eprintln!(
|
||
"[bridge/loop] skipped latch bb{} -> cond bb{}",
|
||
bend.0, cond_bb.0
|
||
);
|
||
}
|
||
|
||
// After the loop, keep vars mapped to the PHI values (current loop state)
|
||
for (name, &phi) in &phi_map {
|
||
vars.insert(name.clone(), phi);
|
||
}
|
||
|
||
Ok(exit_bb)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn lower_stmt_list_with_vars(
|
||
f: &mut MirFunction,
|
||
start_bb: BasicBlockId,
|
||
stmts: &[StmtV0],
|
||
vars: &mut std::collections::HashMap<String, crate::mir::ValueId>,
|
||
loop_stack: &mut Vec<LoopContext>,
|
||
) -> Result<BasicBlockId, String> {
|
||
let mut cur = start_bb;
|
||
for s in stmts {
|
||
cur = lower_stmt_with_vars(f, cur, s, vars, loop_stack)?;
|
||
if let Some(bb) = f.blocks.get(&cur) {
|
||
if bb.is_terminated() {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
Ok(cur)
|
||
}
|
||
fn lower_args_with_vars(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
args: &[ExprV0],
|
||
vars: &mut std::collections::HashMap<String, crate::mir::ValueId>,
|
||
) -> Result<(Vec<crate::mir::ValueId>, BasicBlockId), String> {
|
||
let mut out = Vec::with_capacity(args.len());
|
||
let mut cur = cur_bb;
|
||
for a in args {
|
||
let (v, c) = lower_expr_with_vars(f, cur, a, vars)?;
|
||
out.push(v);
|
||
cur = c;
|
||
}
|
||
Ok((out, cur))
|
||
}
|
||
|
||
fn lower_args(
|
||
f: &mut MirFunction,
|
||
cur_bb: BasicBlockId,
|
||
args: &[ExprV0],
|
||
) -> Result<(Vec<crate::mir::ValueId>, BasicBlockId), String> {
|
||
let mut out = Vec::with_capacity(args.len());
|
||
let mut cur = cur_bb;
|
||
for a in args {
|
||
let (v, c) = lower_expr(f, cur, a)?;
|
||
out.push(v);
|
||
cur = c;
|
||
}
|
||
Ok((out, cur))
|
||
}
|
||
|
||
pub fn maybe_dump_mir(module: &MirModule) {
|
||
if std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1") {
|
||
let p = MirPrinter::new();
|
||
println!("{}", p.print_module(module));
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::parse_json_v0_to_module;
|
||
use crate::mir::{BasicBlockId, MirInstruction, MirModule};
|
||
|
||
fn block_terminator(module: &MirModule, block: BasicBlockId) -> MirInstruction {
|
||
module
|
||
.get_function("main")
|
||
.unwrap()
|
||
.get_block(block)
|
||
.and_then(|bb| bb.terminator.clone())
|
||
.expect("terminator")
|
||
}
|
||
|
||
#[test]
|
||
fn stage3_break_jumps_to_exit() {
|
||
let json = "{\"version\":0,\"kind\":\"Program\",\"body\":[{\"type\":\"Loop\",\"cond\":{\"type\":\"Bool\",\"value\":true},\"body\":[{\"type\":\"Break\"}]},{\"type\":\"Return\",\"expr\":{\"type\":\"Int\",\"value\":0}}]}";
|
||
let module = parse_json_v0_to_module(json).unwrap();
|
||
match block_terminator(&module, BasicBlockId::new(2)) {
|
||
MirInstruction::Jump { target, .. } => assert_eq!(target, BasicBlockId::new(3)),
|
||
other => panic!("expected jump, got {:?}", other),
|
||
}
|
||
module.verify().unwrap();
|
||
}
|
||
|
||
#[test]
|
||
fn stage3_continue_jumps_to_head() {
|
||
let json = "{\"version\":0,\"kind\":\"Program\",\"body\":[{\"type\":\"Loop\",\"cond\":{\"type\":\"Bool\",\"value\":true},\"body\":[{\"type\":\"Continue\"}]},{\"type\":\"Return\",\"expr\":{\"type\":\"Int\",\"value\":0}}]}";
|
||
let module = parse_json_v0_to_module(json).unwrap();
|
||
match block_terminator(&module, BasicBlockId::new(2)) {
|
||
MirInstruction::Jump { target, .. } => assert_eq!(target, BasicBlockId::new(1)),
|
||
other => panic!("expected jump, got {:?}", other),
|
||
}
|
||
module.verify().unwrap();
|
||
}
|
||
}
|
||
|
||
// ========== Direct bridge (source → JSON v0 → MIR) ==========
|
||
|
||
#[derive(Clone, Debug)]
|
||
enum Tok {
|
||
Return,
|
||
Int(i64),
|
||
Plus,
|
||
Minus,
|
||
Star,
|
||
Slash,
|
||
LParen,
|
||
RParen,
|
||
Eof,
|
||
}
|
||
|
||
fn lex(input: &str) -> Result<Vec<Tok>, String> {
|
||
let bytes = input.as_bytes();
|
||
let mut i = 0usize;
|
||
let n = bytes.len();
|
||
let mut toks = Vec::new();
|
||
while i < n {
|
||
let c = bytes[i] as char;
|
||
// Treat semicolon as whitespace (Stage-1 minimal ASI: optional ';')
|
||
if c.is_whitespace() || c == ';' {
|
||
i += 1;
|
||
continue;
|
||
}
|
||
match c {
|
||
'+' => {
|
||
toks.push(Tok::Plus);
|
||
i += 1;
|
||
}
|
||
'-' => {
|
||
toks.push(Tok::Minus);
|
||
i += 1;
|
||
}
|
||
'*' => {
|
||
toks.push(Tok::Star);
|
||
i += 1;
|
||
}
|
||
'/' => {
|
||
toks.push(Tok::Slash);
|
||
i += 1;
|
||
}
|
||
'(' => {
|
||
toks.push(Tok::LParen);
|
||
i += 1;
|
||
}
|
||
')' => {
|
||
toks.push(Tok::RParen);
|
||
i += 1;
|
||
}
|
||
'0'..='9' => {
|
||
let start = i;
|
||
while i < n {
|
||
let cc = bytes[i] as char;
|
||
if cc.is_ascii_digit() {
|
||
i += 1;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
let s = std::str::from_utf8(&bytes[start..i]).unwrap();
|
||
let v: i64 = s.parse().map_err(|_| "invalid int")?;
|
||
toks.push(Tok::Int(v));
|
||
}
|
||
'r' => {
|
||
// return
|
||
if i + 6 <= n && &input[i..i + 6] == "return" {
|
||
toks.push(Tok::Return);
|
||
i += 6;
|
||
} else {
|
||
return Err("unexpected 'r'".into());
|
||
}
|
||
}
|
||
_ => return Err(format!("unexpected char '{}'", c)),
|
||
}
|
||
}
|
||
toks.push(Tok::Eof);
|
||
Ok(toks)
|
||
}
|
||
|
||
struct P {
|
||
toks: Vec<Tok>,
|
||
pos: usize,
|
||
}
|
||
impl P {
|
||
fn new(toks: Vec<Tok>) -> Self {
|
||
Self { toks, pos: 0 }
|
||
}
|
||
fn peek(&self) -> &Tok {
|
||
self.toks.get(self.pos).unwrap()
|
||
}
|
||
fn next(&mut self) -> Tok {
|
||
let t = self.toks.get(self.pos).unwrap().clone();
|
||
self.pos += 1;
|
||
t
|
||
}
|
||
fn expect_return(&mut self) -> Result<(), String> {
|
||
match self.next() {
|
||
Tok::Return => Ok(()),
|
||
_ => Err("expected 'return'".into()),
|
||
}
|
||
}
|
||
fn parse_program(&mut self) -> Result<ExprV0, String> {
|
||
self.expect_return()?;
|
||
self.parse_expr()
|
||
}
|
||
fn parse_expr(&mut self) -> Result<ExprV0, String> {
|
||
let mut left = self.parse_term()?;
|
||
loop {
|
||
match self.peek() {
|
||
Tok::Plus => {
|
||
self.next();
|
||
let r = self.parse_term()?;
|
||
left = ExprV0::Binary {
|
||
op: "+".into(),
|
||
lhs: Box::new(left),
|
||
rhs: Box::new(r),
|
||
};
|
||
}
|
||
Tok::Minus => {
|
||
self.next();
|
||
let r = self.parse_term()?;
|
||
left = ExprV0::Binary {
|
||
op: "-".into(),
|
||
lhs: Box::new(left),
|
||
rhs: Box::new(r),
|
||
};
|
||
}
|
||
_ => break,
|
||
}
|
||
}
|
||
Ok(left)
|
||
}
|
||
fn parse_term(&mut self) -> Result<ExprV0, String> {
|
||
let mut left = self.parse_factor()?;
|
||
loop {
|
||
match self.peek() {
|
||
Tok::Star => {
|
||
self.next();
|
||
let r = self.parse_factor()?;
|
||
left = ExprV0::Binary {
|
||
op: "*".into(),
|
||
lhs: Box::new(left),
|
||
rhs: Box::new(r),
|
||
};
|
||
}
|
||
Tok::Slash => {
|
||
self.next();
|
||
let r = self.parse_factor()?;
|
||
left = ExprV0::Binary {
|
||
op: "/".into(),
|
||
lhs: Box::new(left),
|
||
rhs: Box::new(r),
|
||
};
|
||
}
|
||
_ => break,
|
||
}
|
||
}
|
||
Ok(left)
|
||
}
|
||
fn parse_factor(&mut self) -> Result<ExprV0, String> {
|
||
match self.next() {
|
||
Tok::Int(v) => Ok(ExprV0::Int {
|
||
value: serde_json::Value::from(v),
|
||
}),
|
||
Tok::LParen => {
|
||
let e = self.parse_expr()?;
|
||
match self.next() {
|
||
Tok::RParen => Ok(e),
|
||
_ => Err(") expected".into()),
|
||
}
|
||
}
|
||
_ => Err("factor expected".into()),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn parse_source_v0_to_json(input: &str) -> Result<String, String> {
|
||
let toks = lex(input)?;
|
||
let mut p = P::new(toks);
|
||
let expr = p.parse_program()?;
|
||
let prog = ProgramV0 {
|
||
version: 0,
|
||
kind: "Program".into(),
|
||
body: vec![StmtV0::Return { expr }],
|
||
};
|
||
serde_json::to_string(&prog).map_err(|e| e.to_string())
|
||
}
|
||
|
||
pub fn parse_source_v0_to_module(input: &str) -> Result<MirModule, String> {
|
||
let json = parse_source_v0_to_json(input)?;
|
||
if std::env::var("NYASH_DUMP_JSON_IR").ok().as_deref() == Some("1") {
|
||
println!("{}", json);
|
||
}
|
||
parse_json_v0_to_module(&json)
|
||
}
|