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

using: safer seam defaults (fix_braces OFF by default) + path-alias handling; json_native: robust integer parse + EscapeUtils unquote; add JsonCompat layer; builder: preindex static methods + fallback for bare calls; diagnostics: seam dump + function-call trace

Browse Source
This commit is contained in:
Selfhosting Dev
2025-09-25 10:23:14 +09:00
parent 2f306dd6a5
commit 9384c80623
30 changed files with 1786 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/mir/builder/phi.rs
View File

@ -1,109 +1,11 @@
use super::MirBuilder;
use crate::ast::ASTNode;
use crate::mir::{BasicBlockId, MirFunction, MirInstruction, MirType, ValueId};
use crate::mir::{BasicBlockId, MirInstruction, ValueId};
use std::collections::HashMap;
// PHI-based return type inference helper
pub(super) fn infer_type_from_phi(
function: &MirFunction,
ret_val: ValueId,
types: &HashMap<ValueId, MirType>,
) -> Option<MirType> {
for (_bid, bb) in function.blocks.iter() {
for inst in bb.instructions.iter() {
if let MirInstruction::Phi { dst, inputs } = inst {
if *dst == ret_val {
let mut it = inputs.iter().filter_map(|(_, v)| types.get(v));
if let Some(first) = it.next() {
if it.all(|mt| mt == first) {
return Some(first.clone());
}
}
}
}
}
}
None
}
// Local helper for if-statement analysis (moved from stmts.rs)
pub(super) fn extract_assigned_var(ast: &ASTNode) -> Option<String> {
match ast {
ASTNode::Assignment { target, .. } => {
if let ASTNode::Variable { name, .. } = target.as_ref() {
Some(name.clone())
} else {
None
}
}
ASTNode::Program { statements, .. } => {
statements.last().and_then(|st| extract_assigned_var(st))
}
ASTNode::If {
then_body,
else_body,
..
} => {
// Look into nested if: if both sides assign the same variable, propagate that name upward.
let then_prog = ASTNode::Program {
statements: then_body.clone(),
span: crate::ast::Span::unknown(),
};
let tvar = extract_assigned_var(&then_prog);
let evar = else_body.as_ref().and_then(|eb| {
let ep = ASTNode::Program {
statements: eb.clone(),
span: crate::ast::Span::unknown(),
};
extract_assigned_var(&ep)
});
match (tvar, evar) {
(Some(tv), Some(ev)) if tv == ev => Some(tv),
_ => None,
}
}
_ => None,
}
}
// Local helper has moved to phi_core::if_phi; keep call sites minimal
impl MirBuilder {
#[inline]
#[cfg(debug_assertions)]
fn debug_verify_phi_inputs(&self, inputs: &Vec<(BasicBlockId, ValueId)>) {
use std::collections::HashSet;
if let Some(cur_bb) = self.current_block {
let mut seen = HashSet::new();
for (pred, _v) in inputs.iter() {
debug_assert_ne!(
*pred, cur_bb,
"PHI incoming predecessor must not be the merge block itself"
);
debug_assert!(
seen.insert(*pred),
"Duplicate PHI incoming predecessor detected: {:?}",
pred
);
}
// Ensure all incoming predecessors are known CFG predecessors of the merge block
if let Some(func) = &self.current_function {
if let Some(block) = func.blocks.get(&cur_bb) {
for (pred, _v) in inputs.iter() {
debug_assert!(
block.predecessors.contains(pred),
"PHI incoming pred {:?} is not a predecessor of merge bb {:?}",
pred,
cur_bb
);
}
}
}
}
}
#[inline]
#[cfg(not(debug_assertions))]
fn debug_verify_phi_inputs(&self, _inputs: &Vec<(BasicBlockId, ValueId)>) {}
/// Merge all variables modified in then/else relative to pre_if_snapshot.
/// In PHI-off mode inserts edge copies from branch exits to merge. In PHI-on mode emits Phi.
/// `skip_var` allows skipping a variable already merged elsewhere (e.g., bound to an expression result).
@ -118,37 +20,23 @@ impl MirBuilder {
else_map_end_opt: &Option<std::collections::HashMap<String, super::ValueId>>,
skip_var: Option<&str>,
) -> Result<(), String> {
use std::collections::HashSet;
let mut names: HashSet<&str> = HashSet::new();
for k in then_map_end.keys() { names.insert(k.as_str()); }
if let Some(emap) = else_map_end_opt.as_ref() {
for k in emap.keys() { names.insert(k.as_str()); }
}
// Only variables that changed against pre_if_snapshot
let mut changed: Vec<&str> = Vec::new();
for &name in &names {
let pre = pre_if_snapshot.get(name);
let t = then_map_end.get(name);
let e = else_map_end_opt.as_ref().and_then(|m| m.get(name));
// changed when either branch value differs from pre
if (t.is_some() && Some(t.copied().unwrap()) != pre.copied())
|| (e.is_some() && Some(e.copied().unwrap()) != pre.copied())
{
changed.push(name);
}
}
let changed = crate::mir::phi_core::if_phi::compute_modified_names(
pre_if_snapshot,
then_map_end,
else_map_end_opt,
);
for name in changed {
if skip_var.map(|s| s == name).unwrap_or(false) {
continue;
}
let pre = match pre_if_snapshot.get(name) {
let pre = match pre_if_snapshot.get(name.as_str()) {
Some(v) => *v,
None => continue, // unknown before-if; skip
};
let then_v = then_map_end.get(name).copied().unwrap_or(pre);
let then_v = then_map_end.get(name.as_str()).copied().unwrap_or(pre);
let else_v = else_map_end_opt
.as_ref()
.and_then(|m| m.get(name).copied())
.and_then(|m| m.get(name.as_str()).copied())
.unwrap_or(pre);
// フェーズM: 常にPHI命令を使用（no_phi_mode撤廃）
// incoming の predecessor は "実際に merge に遷移してくる出口ブロック" を使用する
@ -156,9 +44,11 @@ impl MirBuilder {
let else_pred = else_exit_block_opt.unwrap_or(else_block);
let merged = self.value_gen.next();
let inputs = vec![(then_pred, then_v), (else_pred, else_v)];
self.debug_verify_phi_inputs(&inputs);
if let (Some(func), Some(cur_bb)) = (&self.current_function, self.current_block) {
crate::mir::phi_core::common::debug_verify_phi_inputs(func, cur_bb, &inputs);
}
self.emit_instruction(MirInstruction::Phi { dst: merged, inputs })?;
self.variable_map.insert(name.to_string(), merged);
self.variable_map.insert(name, merged);
}
Ok(())
}
@ -181,10 +71,10 @@ impl MirBuilder {
) -> Result<ValueId, String> {
// If only the then-branch assigns a variable (e.g., `if c { x = ... }`) and the else
// does not assign the same variable, bind that variable to a Phi of (then_value, pre_if_value).
let assigned_var_then = extract_assigned_var(then_ast_for_analysis);
let assigned_var_then = crate::mir::phi_core::if_phi::extract_assigned_var(then_ast_for_analysis);
let assigned_var_else = else_ast_for_analysis
.as_ref()
.and_then(|a| extract_assigned_var(a));
.and_then(|a| crate::mir::phi_core::if_phi::extract_assigned_var(a));
let result_val = self.value_gen.next();
// フェーズM: no_phi_mode分岐削除（常にPHI命令を使用）
@ -213,7 +103,9 @@ impl MirBuilder {
let else_pred = else_exit_block_opt.unwrap_or(else_block);
// Emit Phi for the assigned variable and bind it
let inputs = vec![(then_pred, then_value_for_var), (else_pred, else_value_for_var)];
self.debug_verify_phi_inputs(&inputs);
if let (Some(func), Some(cur_bb)) = (&self.current_function, self.current_block) {
crate::mir::phi_core::common::debug_verify_phi_inputs(func, cur_bb, &inputs);
}
self.emit_instruction(MirInstruction::Phi { dst: result_val, inputs })?;
self.variable_map = pre_if_var_map.clone();
self.variable_map.insert(var_name, result_val);
@ -222,7 +114,9 @@ impl MirBuilder {
let then_pred = then_exit_block_opt.unwrap_or(then_block);
let else_pred = else_exit_block_opt.unwrap_or(else_block);
let inputs = vec![(then_pred, then_value_raw), (else_pred, else_value_raw)];
self.debug_verify_phi_inputs(&inputs);
if let (Some(func), Some(cur_bb)) = (&self.current_function, self.current_block) {
crate::mir::phi_core::common::debug_verify_phi_inputs(func, cur_bb, &inputs);
}
self.emit_instruction(MirInstruction::Phi { dst: result_val, inputs })?;
// Merge variable map conservatively to pre-if snapshot (no new bindings)
self.variable_map = pre_if_var_map.clone();