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

🎉 Phase 11.8/12.7: MIR Core-13 完全実装 + 糖衣構文ドキュメント更新

Browse Source 
主要な変更:
- MIR Core-13命令セット確定（Load/Store削除の革命的設計）
  - Const, BinOp, Compare（値・計算）
  - Jump, Branch, Return, Phi（制御）
  - Call, BoxCall, ExternCall（呼び出し）
  - TypeOp, Safepoint, Barrier（メタ）
- Phase 12.7糖衣構文ドキュメント整理（超圧縮重視、可逆変換保証）
- MIRビルダーのモジュール分割完了
- vtableテストスイート拡充
- AI協調開発ツール追加（並列リファクタリング支援）

詳細:
- src/mir/instruction_introspection.rs: core13_instruction_names()追加
- MIRビルダー分割: decls.rs, exprs_*.rs, fields.rs
- plugin_loader_v2: errors.rs, host_bridge.rs分離
- 論文用データ: mir13-final.md作成

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
2025-09-04 11:34:15 +09:00
parent 4e824fa00e
commit fb2d8e37d5
62 changed files with 3632 additions and 835 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/mir/builder/decls.rs Normal file
View File

@ -0,0 +1,107 @@
// Declarations lowering: static boxes and box declarations
use super::{MirInstruction, ConstValue, ValueId, BasicBlockId};
use crate::ast::ASTNode;
use std::collections::HashSet;
use crate::mir::slot_registry::{get_or_assign_type_id, reserve_method_slot};
impl super::MirBuilder {
/// Build static box (e.g., Main) - extracts main() method body and converts to Program
/// Also lowers other static methods into standalone MIR functions: BoxName.method/N
pub(super) fn build_static_main_box(
&mut self,
box_name: String,
methods: std::collections::HashMap<String, ASTNode>,
) -> Result<ValueId, String> {
// Lower other static methods (except main) to standalone MIR functions so JIT can see them
for (mname, mast) in methods.iter() {
if mname == "main" { continue; }
if let ASTNode::FunctionDeclaration { params, body, .. } = mast {
let func_name = format!("{}.{}{}", box_name, mname, format!("/{}", params.len()));
self.lower_static_method_as_function(func_name, params.clone(), body.clone())?;
}
}
// Within this lowering, treat `me` receiver as this static box
let saved_static = self.current_static_box.clone();
self.current_static_box = Some(box_name.clone());
// Look for the main() method
let out = if let Some(main_method) = methods.get("main") {
if let ASTNode::FunctionDeclaration { params, body, .. } = main_method {
// Convert the method body to a Program AST node and lower it
let program_ast = ASTNode::Program { statements: body.clone(), span: crate::ast::Span::unknown() };
// Bind default parameters if present (e.g., args=[])
let saved_var_map = std::mem::take(&mut self.variable_map);
for p in params.iter() {
let pid = self.value_gen.next();
if p == "args" {
// new ArrayBox() with no args
self.emit_instruction(MirInstruction::NewBox { dst: pid, box_type: "ArrayBox".to_string(), args: vec![] })?;
} else {
self.emit_instruction(MirInstruction::Const { dst: pid, value: ConstValue::Void })?;
}
self.variable_map.insert(p.clone(), pid);
}
let lowered = self.build_expression(program_ast);
self.variable_map = saved_var_map;
lowered
} else {
Err("main method in static box is not a FunctionDeclaration".to_string())
}
} else {
Err("static box must contain a main() method".to_string())
};
// Restore static box context
self.current_static_box = saved_static;
out
}
/// Build box declaration: box Name { fields... methods... }
pub(super) fn build_box_declaration(
&mut self,
name: String,
methods: std::collections::HashMap<String, ASTNode>,
fields: Vec<String>,
weak_fields: Vec<String>,
) -> Result<(), String> {
// Create a type registration constant (marker)
let type_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: type_id, value: ConstValue::String(format!("__box_type_{}", name)) })?;
// Emit field metadata markers
for field in fields {
let field_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_id, value: ConstValue::String(format!("__field_{}_{}", name, field)) })?;
}
// Record weak fields for this box
if !weak_fields.is_empty() {
let set: HashSet<String> = weak_fields.into_iter().collect();
self.weak_fields_by_box.insert(name.clone(), set);
}
// Reserve method slots for user-defined instance methods (deterministic, starts at 4)
let mut instance_methods: Vec<String> = Vec::new();
for (mname, mast) in &methods {
if let ASTNode::FunctionDeclaration { is_static, .. } = mast {
if !*is_static { instance_methods.push(mname.clone()); }
}
}
instance_methods.sort();
if !instance_methods.is_empty() {
let tyid = get_or_assign_type_id(&name);
for (i, m) in instance_methods.iter().enumerate() {
let slot = 4u16.saturating_add(i as u16);
reserve_method_slot(tyid, m, slot);
}
}
// Emit markers for declared methods (kept as metadata hints)
for (method_name, method_ast) in methods {
if let ASTNode::FunctionDeclaration { .. } = method_ast {
let method_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: method_id, value: ConstValue::String(format!("__method_{}_{}", name, method_name)) })?;
}
}
Ok(())
}
}

181
src/mir/builder/exprs.rs
View File

@ -5,6 +5,16 @@ use crate::ast::{ASTNode, LiteralValue};
impl super::MirBuilder {
// Main expression dispatcher
pub(super) fn build_expression_impl(&mut self, ast: ASTNode) -> Result<ValueId, String> {
if matches!(ast,
ASTNode::Program { .. }
| ASTNode::Print { .. }
| ASTNode::If { .. }
| ASTNode::Loop { .. }
| ASTNode::TryCatch { .. }
| ASTNode::Throw { .. }
) {
return self.build_expression_impl_legacy(ast);
}
match ast {
ASTNode::Literal { value, .. } => self.build_literal(value),
@ -53,116 +63,17 @@ impl super::MirBuilder {
ASTNode::FunctionCall { name, arguments, .. } =>
self.build_function_call(name.clone(), arguments.clone()),
ASTNode::Call { callee, arguments, .. } => {
let mut arg_ids: Vec<ValueId> = Vec::new();
let callee_id = self.build_expression_impl(*callee.clone())?;
for a in arguments { arg_ids.push(self.build_expression_impl(a)?); }
let dst = self.value_gen.next();
self.emit_instruction(MirInstruction::Call { dst: Some(dst), func: callee_id, args: arg_ids, effects: crate::mir::EffectMask::PURE })?;
Ok(dst)
}
ASTNode::Call { callee, arguments, .. } =>
self.build_indirect_call_expression(*callee.clone(), arguments.clone()),
ASTNode::QMarkPropagate { expression, .. } => {
let res_val = self.build_expression_impl(*expression.clone())?;
let ok_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(ok_id), box_val: res_val, method: "isOk".to_string(), args: vec![], effects: crate::mir::EffectMask::PURE })?;
let then_block = self.block_gen.next();
let else_block = self.block_gen.next();
self.emit_instruction(MirInstruction::Branch { condition: ok_id, then_bb: then_block, else_bb: else_block })?;
self.start_new_block(then_block)?;
self.emit_instruction(MirInstruction::Return { value: Some(res_val) })?;
self.start_new_block(else_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(val_id), box_val: res_val, method: "getValue".to_string(), args: vec![], effects: crate::mir::EffectMask::PURE })?;
Ok(val_id)
}
ASTNode::QMarkPropagate { expression, .. } =>
self.build_qmark_propagate_expression(*expression.clone()),
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
let scr_val = self.build_expression_impl(*scrutinee.clone())?;
let merge_block: BasicBlockId = self.block_gen.next();
let result_val = self.value_gen.next();
let mut phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
let mut next_block = self.block_gen.next();
self.start_new_block(next_block)?;
for (i, (label, arm_expr)) in arms.iter().enumerate() {
let then_block = self.block_gen.next();
if let LiteralValue::String(ref s) = label {
let lit_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: lit_id, value: ConstValue::String(s.clone()) })?;
let cond_id = self.value_gen.next();
self.emit_instruction(crate::mir::MirInstruction::Compare { dst: cond_id, op: crate::mir::CompareOp::Eq, lhs: scr_val, rhs: lit_id })?;
self.emit_instruction(crate::mir::MirInstruction::Branch { condition: cond_id, then_bb: then_block, else_bb: next_block })?;
self.start_new_block(then_block)?;
let then_val = self.build_expression_impl(arm_expr.clone())?;
phi_inputs.push((then_block, then_val));
self.emit_instruction(crate::mir::MirInstruction::Jump { target: merge_block })?;
if i < arms.len() - 1 { let b = self.block_gen.next(); self.start_new_block(b)?; next_block = b; }
}
}
let else_block_id = next_block; self.start_new_block(else_block_id)?;
let else_val = self.build_expression_impl(*else_expr.clone())?;
phi_inputs.push((else_block_id, else_val));
self.emit_instruction(crate::mir::MirInstruction::Jump { target: merge_block })?;
self.start_new_block(merge_block)?;
self.emit_instruction(crate::mir::MirInstruction::Phi { dst: result_val, inputs: phi_inputs })?;
Ok(result_val)
}
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } =>
self.build_peek_expression(*scrutinee.clone(), arms.clone(), *else_expr.clone()),
ASTNode::Lambda { params, body, .. } => {
use std::collections::HashSet;
let mut used: HashSet<String> = HashSet::new();
let mut locals: HashSet<String> = HashSet::new(); for p in &params { locals.insert(p.clone()); }
fn collect_vars(ast: &ASTNode, used: &mut std::collections::HashSet<String>, locals: &mut std::collections::HashSet<String>) {
match ast {
ASTNode::Variable { name, .. } => { if !locals.contains(name) { used.insert(name.clone()); } }
ASTNode::Assignment { target, value, .. } => { collect_vars(target, used, locals); collect_vars(value, used, locals); }
ASTNode::BinaryOp { left, right, .. } => { collect_vars(left, used, locals); collect_vars(right, used, locals); }
ASTNode::UnaryOp { operand, .. } => { collect_vars(operand, used, locals); }
ASTNode::MethodCall { object, arguments, .. } => { collect_vars(object, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FunctionCall { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::Call { callee, arguments, .. } => { collect_vars(callee, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FieldAccess { object, .. } => { collect_vars(object, used, locals); }
ASTNode::New { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::If { condition, then_body, else_body, .. } => {
collect_vars(condition, used, locals);
for st in then_body { collect_vars(st, used, locals); }
if let Some(eb) = else_body { for st in eb { collect_vars(st, used, locals); } }
}
ASTNode::Loop { condition, body, .. } => { collect_vars(condition, used, locals); for st in body { collect_vars(st, used, locals); } }
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
for st in try_body { collect_vars(st, used, locals); }
for c in catch_clauses { for st in &c.body { collect_vars(st, used, locals); } }
if let Some(fb) = finally_body { for st in fb { collect_vars(st, used, locals); } }
}
ASTNode::Throw { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Print { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Return { value, .. } => { if let Some(v) = value { collect_vars(v, used, locals); } }
ASTNode::AwaitExpression { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
collect_vars(scrutinee, used, locals);
for (_, e) in arms { collect_vars(e, used, locals); }
collect_vars(else_expr, used, locals);
}
ASTNode::Program { statements, .. } => { for st in statements { collect_vars(st, used, locals); } }
ASTNode::FunctionDeclaration { params, body, .. } => {
let mut inner = locals.clone();
for p in params { inner.insert(p.clone()); }
for st in body { collect_vars(st, used, &mut inner); }
}
_ => {}
}
}
for st in body.iter() { collect_vars(st, &mut used, &mut locals); }
let mut captures: Vec<(String, ValueId)> = Vec::new();
for name in used.into_iter() {
if let Some(&vid) = self.variable_map.get(&name) { captures.push((name, vid)); }
}
let me = self.variable_map.get("me").copied();
let dst = self.value_gen.next();
self.emit_instruction(MirInstruction::FunctionNew { dst, params: params.clone(), body: body.clone(), captures, me })?;
self.value_types.insert(dst, crate::mir::MirType::Box("FunctionBox".to_string()));
Ok(dst)
}
ASTNode::Lambda { params, body, .. } =>
self.build_lambda_expression(params.clone(), body.clone()),
ASTNode::Return { value, .. } => self.build_return_statement(value.clone()),
@ -207,37 +118,35 @@ impl super::MirBuilder {
ASTNode::AwaitExpression { expression, .. } =>
self.build_await_expression(*expression.clone()),
ASTNode::Include { filename, .. } => {
let mut path = super::utils::resolve_include_path_builder(&filename);
if std::path::Path::new(&path).is_dir() {
path = format!("{}/index.nyash", path.trim_end_matches('/'));
} else if std::path::Path::new(&path).extension().is_none() {
path.push_str(".nyash");
}
if self.include_loading.contains(&path) {
return Err(format!("Circular include detected: {}", path));
}
if let Some(name) = self.include_box_map.get(&path).cloned() {
return self.build_new_expression(name, vec![]);
}
self.include_loading.insert(path.clone());
let content = std::fs::read_to_string(&path)
.map_err(|e| format!("Include read error '{}': {}", filename, e))?;
let included_ast = crate::parser::NyashParser::parse_from_string(&content)
.map_err(|e| format!("Include parse error '{}': {:?}", filename, e))?;
let mut box_name: Option<String> = None;
if let ASTNode::Program { statements, .. } = &included_ast {
for st in statements {
if let ASTNode::BoxDeclaration { name, is_static, .. } = st { if *is_static { box_name = Some(name.clone()); break; } }
}
}
let bname = box_name.ok_or_else(|| format!("Include target '{}' has no static box", filename))?;
let _ = self.build_expression_impl(included_ast)?;
self.include_loading.remove(&path);
self.include_box_map.insert(path.clone(), bname.clone());
self.build_new_expression(bname, vec![])
ASTNode::Include { filename, .. } =>
self.build_include_expression(filename.clone()),
ASTNode::Program { statements, .. } =>
self.build_block(statements.clone()),
ASTNode::Print { expression, .. } =>
self.build_print_statement(*expression.clone()),
ASTNode::If { condition, then_body, else_body, .. } => {
let else_ast = if let Some(else_statements) = else_body {
Some(ASTNode::Program { statements: else_statements.clone(), span: crate::ast::Span::unknown() })
} else { None };
self.build_if_statement(
*condition.clone(),
ASTNode::Program { statements: then_body.clone(), span: crate::ast::Span::unknown() },
else_ast,
)
}
ASTNode::Loop { condition, body, .. } =>
self.build_loop_statement(*condition.clone(), body.clone()),
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } =>
self.build_try_catch_statement(try_body.clone(), catch_clauses.clone(), finally_body.clone()),
ASTNode::Throw { expression, .. } =>
self.build_throw_statement(*expression.clone()),
_ => Err(format!("Unsupported AST node type: {:?}", ast)),
}
}

24
src/mir/builder/exprs_call.rs Normal file
View File

@ -0,0 +1,24 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// Indirect call: (callee)(args...)
pub(super) fn build_indirect_call_expression(
&mut self,
callee: ASTNode,
arguments: Vec<ASTNode>,
) -> Result<ValueId, String> {
let callee_id = self.build_expression_impl(callee)?;
let mut arg_ids: Vec<ValueId> = Vec::new();
for a in arguments { arg_ids.push(self.build_expression_impl(a)?); }
let dst = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Call {
dst: Some(dst),
func: callee_id,
args: arg_ids,
effects: super::EffectMask::PURE,
})?;
Ok(dst)
}
}

27
src/mir/builder/exprs_include.rs Normal file
View File

@ -0,0 +1,27 @@
use super::ValueId;
impl super::MirBuilder {
// Include lowering: include "path"
pub(super) fn build_include_expression(&mut self, filename: String) -> Result<ValueId, String> {
let mut path = super::utils::resolve_include_path_builder(&filename);
if std::path::Path::new(&path).is_dir() { path = format!("{}/index.nyash", path.trim_end_matches('/')); }
else if std::path::Path::new(&path).extension().is_none() { path.push_str(".nyash"); }
if self.include_loading.contains(&path) { return Err(format!("Circular include detected: {}", path)); }
if let Some(name) = self.include_box_map.get(&path).cloned() { return self.build_new_expression(name, vec![]); }
self.include_loading.insert(path.clone());
let content = std::fs::read_to_string(&path).map_err(|e| format!("Include read error '{}': {}", filename, e))?;
let included_ast = crate::parser::NyashParser::parse_from_string(&content).map_err(|e| format!("Include parse error '{}': {:?}", filename, e))?;
let mut box_name: Option<String> = None;
if let crate::ast::ASTNode::Program { statements, .. } = &included_ast {
for st in statements { if let crate::ast::ASTNode::BoxDeclaration { name, is_static, .. } = st { if *is_static { box_name = Some(name.clone()); break; } } }
}
let bname = box_name.ok_or_else(|| format!("Include target '{}' has no static box", filename))?;
let _ = self.build_expression_impl(included_ast)?;
self.include_loading.remove(&path);
self.include_box_map.insert(path.clone(), bname.clone());
self.build_new_expression(bname, vec![])
}
}

67
src/mir/builder/exprs_lambda.rs Normal file
View File

@ -0,0 +1,67 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// Lambda lowering to FunctionNew
pub(super) fn build_lambda_expression(
&mut self,
params: Vec<String>,
body: Vec<ASTNode>,
) -> Result<ValueId, String> {
use std::collections::HashSet;
let mut used: HashSet<String> = HashSet::new();
let mut locals: HashSet<String> = HashSet::new();
for p in &params { locals.insert(p.clone()); }
fn collect_vars(ast: &ASTNode, used: &mut std::collections::HashSet<String>, locals: &mut std::collections::HashSet<String>) {
match ast {
ASTNode::Variable { name, .. } => { if !locals.contains(name) { used.insert(name.clone()); } }
ASTNode::Assignment { target, value, .. } => { collect_vars(target, used, locals); collect_vars(value, used, locals); }
ASTNode::BinaryOp { left, right, .. } => { collect_vars(left, used, locals); collect_vars(right, used, locals); }
ASTNode::UnaryOp { operand, .. } => { collect_vars(operand, used, locals); }
ASTNode::MethodCall { object, arguments, .. } => { collect_vars(object, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FunctionCall { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::Call { callee, arguments, .. } => { collect_vars(callee, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FieldAccess { object, .. } => { collect_vars(object, used, locals); }
ASTNode::New { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::If { condition, then_body, else_body, .. } => {
collect_vars(condition, used, locals);
for st in then_body { collect_vars(st, used, locals); }
if let Some(eb) = else_body { for st in eb { collect_vars(st, used, locals); } }
}
ASTNode::Loop { condition, body, .. } => { collect_vars(condition, used, locals); for st in body { collect_vars(st, used, locals); } }
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
for st in try_body { collect_vars(st, used, locals); }
for c in catch_clauses { for st in &c.body { collect_vars(st, used, locals); } }
if let Some(fb) = finally_body { for st in fb { collect_vars(st, used, locals); } }
}
ASTNode::Throw { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Print { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Return { value, .. } => { if let Some(v) = value { collect_vars(v, used, locals); } }
ASTNode::AwaitExpression { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
collect_vars(scrutinee, used, locals);
for (_, e) in arms { collect_vars(e, used, locals); }
collect_vars(else_expr, used, locals);
}
ASTNode::Program { statements, .. } => { for st in statements { collect_vars(st, used, locals); } }
ASTNode::FunctionDeclaration { params, body, .. } => {
let mut inner = locals.clone();
for p in params { inner.insert(p.clone()); }
for st in body { collect_vars(st, used, &mut inner); }
}
_ => {}
}
}
for st in body.iter() { collect_vars(st, &mut used, &mut locals); }
let mut captures: Vec<(String, ValueId)> = Vec::new();
for name in used.into_iter() {
if let Some(&vid) = self.variable_map.get(&name) { captures.push((name, vid)); }
}
let me = self.variable_map.get("me").copied();
let dst = self.value_gen.next();
self.emit_instruction(super::MirInstruction::FunctionNew { dst, params: params.clone(), body: body.clone(), captures, me })?;
self.value_types.insert(dst, crate::mir::MirType::Box("FunctionBox".to_string()));
Ok(dst)
}
}

50
src/mir/builder/exprs_peek.rs Normal file
View File

@ -0,0 +1,50 @@
use super::{BasicBlockId, ValueId};
use crate::ast::{ASTNode, LiteralValue};
impl super::MirBuilder {
// Peek expression lowering
pub(super) fn build_peek_expression(
&mut self,
scrutinee: ASTNode,
arms: Vec<(LiteralValue, ASTNode)>,
else_expr: ASTNode,
) -> Result<ValueId, String> {
let scr_val = self.build_expression_impl(scrutinee)?;
let merge_block: BasicBlockId = self.block_gen.next();
let result_val = self.value_gen.next();
let mut phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
let mut next_block = self.block_gen.next();
self.start_new_block(next_block)?;
for (i, (label, arm_expr)) in arms.iter().cloned().enumerate() {
let then_block = self.block_gen.next();
// Only string labels handled here (behavior unchanged)
if let LiteralValue::String(s) = label {
let lit_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Const { dst: lit_id, value: super::ConstValue::String(s) })?;
let cond_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Compare { dst: cond_id, op: super::CompareOp::Eq, lhs: scr_val, rhs: lit_id })?;
self.emit_instruction(super::MirInstruction::Branch { condition: cond_id, then_bb: then_block, else_bb: next_block })?;
self.start_new_block(then_block)?;
let then_val = self.build_expression_impl(arm_expr)?;
phi_inputs.push((then_block, then_val));
self.emit_instruction(super::MirInstruction::Jump { target: merge_block })?;
if i < arms.len() - 1 {
let b = self.block_gen.next();
self.start_new_block(b)?;
next_block = b;
}
}
}
let else_block_id = next_block;
self.start_new_block(else_block_id)?;
let else_val = self.build_expression_impl(else_expr)?;
phi_inputs.push((else_block_id, else_val));
self.emit_instruction(super::MirInstruction::Jump { target: merge_block })?;
self.start_new_block(merge_block)?;
self.emit_instruction(super::MirInstruction::Phi { dst: result_val, inputs: phi_inputs })?;
Ok(result_val)
}
}

34
src/mir/builder/exprs_qmark.rs Normal file
View File

@ -0,0 +1,34 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// QMarkPropagate: result?.value (Result-like)
pub(super) fn build_qmark_propagate_expression(&mut self, expression: ASTNode) -> Result<ValueId, String> {
let res_val = self.build_expression_impl(expression)?;
let ok_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::BoxCall {
dst: Some(ok_id),
box_val: res_val,
method: "isOk".to_string(),
args: vec![],
method_id: None,
effects: super::EffectMask::PURE,
})?;
let then_block = self.block_gen.next();
let else_block = self.block_gen.next();
self.emit_instruction(super::MirInstruction::Branch { condition: ok_id, then_bb: then_block, else_bb: else_block })?;
self.start_new_block(then_block)?;
self.emit_instruction(super::MirInstruction::Return { value: Some(res_val) })?;
self.start_new_block(else_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::BoxCall {
dst: Some(val_id),
box_val: res_val,
method: "getValue".to_string(),
args: vec![],
method_id: None,
effects: super::EffectMask::PURE,
})?;
Ok(val_id)
}
}

92
src/mir/builder/fields.rs Normal file
View File

@ -0,0 +1,92 @@
// Field access and assignment lowering
use super::{MirInstruction, ConstValue, ValueId, EffectMask};
use crate::mir::slot_registry;
use crate::ast::ASTNode;
impl super::MirBuilder {
/// Build field access: object.field
pub(super) fn build_field_access(&mut self, object: ASTNode, field: String) -> Result<ValueId, String> {
let object_clone = object.clone();
let object_value = self.build_expression(object)?;
// Emit: field name const
let field_name_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_name_id, value: ConstValue::String(field.clone()) })?;
// BoxCall: getField(name)
let field_val = self.value_gen.next();
self.emit_instruction(MirInstruction::BoxCall {
dst: Some(field_val),
box_val: object_value,
method: "getField".to_string(),
method_id: slot_registry::resolve_slot_by_type_name("InstanceBox", "getField"),
args: vec![field_name_id],
effects: EffectMask::READ,
})?;
// Propagate recorded origin class for this field if any
if let Some(class_name) = self.field_origin_class.get(&(object_value, field.clone())).cloned() {
self.value_origin_newbox.insert(field_val, class_name);
}
// If base is a known newbox and field is weak, emit WeakLoad (+ optional barrier)
let mut inferred_class: Option<String> = self.value_origin_newbox.get(&object_value).cloned();
if inferred_class.is_none() {
if let ASTNode::FieldAccess { object: inner_obj, field: inner_field, .. } = object_clone {
if let Ok(base_id) = self.build_expression(*inner_obj.clone()) {
if let Some(cls) = self.field_origin_class.get(&(base_id, inner_field)).cloned() { inferred_class = Some(cls); }
}
}
}
if let Some(class_name) = inferred_class {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) {
let loaded = self.emit_weak_load(field_val)?;
let _ = self.emit_barrier_read(loaded);
return Ok(loaded);
}
}
}
Ok(field_val)
}
/// Build field assignment: object.field = value
pub(super) fn build_field_assignment(&mut self, object: ASTNode, field: String, value: ASTNode) -> Result<ValueId, String> {
let object_value = self.build_expression(object)?;
let mut value_result = self.build_expression(value)?;
// If base is known and field is weak, create WeakRef before store
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) { value_result = self.emit_weak_new(value_result)?; }
}
}
// Emit: field name const
let field_name_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_name_id, value: ConstValue::String(field.clone()) })?;
// Set the field via BoxCall: setField(name, value)
self.emit_instruction(MirInstruction::BoxCall {
dst: None,
box_val: object_value,
method: "setField".to_string(),
method_id: slot_registry::resolve_slot_by_type_name("InstanceBox", "setField"),
args: vec![field_name_id, value_result],
effects: EffectMask::WRITE,
})?;
// Write barrier if weak field
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) { let _ = self.emit_barrier_write(value_result); }
}
}
// Record origin class for this field value if known
if let Some(class_name) = self.value_origin_newbox.get(&value_result).cloned() {
self.field_origin_class.insert((object_value, field.clone()), class_name);
}
Ok(value_result)
}
}

27
src/mir/builder/utils.rs
View File

@ -1,4 +1,5 @@
use std::fs;
use super::{BasicBlock, BasicBlockId};
// Resolve include path using nyash.toml include.roots if present
pub(super) fn resolve_include_path_builder(filename: &str) -> String {
@ -63,3 +64,29 @@ pub(super) fn infer_type_from_phi(
None
}
// Lightweight helpers moved from builder.rs to reduce file size
impl super::MirBuilder {
/// Ensure a basic block exists in the current function
pub(crate) fn ensure_block_exists(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
if !function.blocks.contains_key(&block_id) {
let block = BasicBlock::new(block_id);
function.add_block(block);
}
Ok(())
} else {
Err("No current function".to_string())
}
}
/// Start a new basic block and set as current
pub(crate) fn start_new_block(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
function.add_block(BasicBlock::new(block_id));
self.current_block = Some(block_id);
Ok(())
} else {
Err("No current function".to_string())
}
}
}