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

pyvm: split op handlers into ops_core/ops_box/ops_ctrl; add ops_flow + intrinsic; delegate vm.py without behavior change

Browse Source 
net-plugin: modularize constants (consts.rs) and sockets (sockets.rs); remove legacy commented socket code; fix unused imports
mir: move instruction unit tests to tests/mir_instruction_unit.rs (file lean-up); no semantic changes
runner/pyvm: ensure using pre-strip; misc docs updates

Build: cargo build ok; legacy cfg warnings remain as before
This commit is contained in:
Selfhosting Dev
2025-09-21 08:53:00 +09:00
parent ee17cfd979
commit c8063c9e41
247 changed files with 10187 additions and 23124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

600
src/mir/builder.rs
View File

@ -204,519 +204,7 @@ impl MirBuilder {
self.build_expression_impl(ast)
}
// build_expression_impl_legacy moved to builder/exprs_legacy.rs
/*
pub(super) fn build_expression_impl_legacy(&mut self, ast: ASTNode) -> Result<ValueId, String> {
match ast {
ASTNode::Literal { value, .. } => self.build_literal(value),
ASTNode::BinaryOp {
left,
operator,
right,
..
} => self.build_binary_op(*left, operator, *right),
ASTNode::UnaryOp {
operator, operand, ..
} => {
let op_string = match operator {
crate::ast::UnaryOperator::Minus => "-".to_string(),
crate::ast::UnaryOperator::Not => "not".to_string(),
};
self.build_unary_op(op_string, *operand)
}
ASTNode::Variable { name, .. } => self.build_variable_access(name.clone()),
ASTNode::Me { .. } => self.build_me_expression(),
ASTNode::MethodCall {
object,
method,
arguments,
..
} => {
// Early TypeOp lowering for method-style is()/as()
if (method == "is" || method == "as") && arguments.len() == 1 {
if let Some(type_name) = Self::extract_string_literal(&arguments[0]) {
let obj_val = self.build_expression(*object.clone())?;
let ty = Self::parse_type_name_to_mir(&type_name);
let dst = self.value_gen.next();
let op = if method == "is" {
super::TypeOpKind::Check
} else {
super::TypeOpKind::Cast
};
self.emit_instruction(MirInstruction::TypeOp {
dst,
op,
value: obj_val,
ty,
})?;
return Ok(dst);
}
}
self.build_method_call(*object.clone(), method.clone(), arguments.clone())
}
ASTNode::FromCall {
parent,
method,
arguments,
..
} => self.build_from_expression(parent.clone(), method.clone(), arguments.clone()),
ASTNode::Assignment { target, value, .. } => {
// Check if target is a field access for RefSet
if let ASTNode::FieldAccess { object, field, .. } = target.as_ref() {
self.build_field_assignment(*object.clone(), field.clone(), *value.clone())
} else if let ASTNode::Variable { name, .. } = target.as_ref() {
// Plain variable assignment - existing behavior
self.build_assignment(name.clone(), *value.clone())
} else {
Err("Complex assignment targets not yet supported in MIR".to_string())
}
}
ASTNode::FunctionCall {
name, arguments, ..
} => {
// Early TypeOp lowering for function-style isType()/asType()
if (name == "isType" || name == "asType") && arguments.len() == 2 {
if let Some(type_name) = Self::extract_string_literal(&arguments[1]) {
let val = self.build_expression(arguments[0].clone())?;
let ty = Self::parse_type_name_to_mir(&type_name);
let dst = self.value_gen.next();
let op = if name == "isType" {
super::TypeOpKind::Check
} else {
super::TypeOpKind::Cast
};
self.emit_instruction(MirInstruction::TypeOp {
dst,
op,
value: val,
ty,
})?;
return Ok(dst);
}
}
self.build_function_call(name.clone(), arguments.clone())
}
ASTNode::Call {
callee, arguments, ..
} => {
// P1.5: Lambdaはインライン、それ以外は Call に正規化
if let ASTNode::Lambda { params, body, .. } = callee.as_ref() {
if params.len() != arguments.len() {
return Err(format!(
"Lambda expects {} args, got {}",
params.len(),
arguments.len()
));
}
let mut arg_vals: Vec<ValueId> = Vec::new();
for a in arguments {
arg_vals.push(self.build_expression(a)?);
}
let saved_vars = self.variable_map.clone();
for (p, v) in params.iter().zip(arg_vals.iter()) {
self.variable_map.insert(p.clone(), *v);
}
let prog = ASTNode::Program {
statements: body.clone(),
span: crate::ast::Span::unknown(),
};
let out = self.build_expression(prog)?;
self.variable_map = saved_vars;
Ok(out)
} else {
// callee/args を評価し、Call を発行（VM 側で FunctionBox/関数名の両対応）
let callee_id = self.build_expression(*callee.clone())?;
let mut arg_ids = Vec::new();
for a in arguments {
arg_ids.push(self.build_expression(a)?);
}
let dst = self.value_gen.next();
self.emit_instruction(MirInstruction::Call {
dst: Some(dst),
func: callee_id,
args: arg_ids,
effects: EffectMask::PURE,
})?;
Ok(dst)
}
}
ASTNode::QMarkPropagate { expression, .. } => {
// Lower: ok = expr.isOk(); br ok then else; else => return expr; then => expr.getValue()
let res_val = self.build_expression(*expression.clone())?;
let ok_id = self.value_gen.next();
self.emit_instruction(MirInstruction::BoxCall {
dst: Some(ok_id),
box_val: res_val,
method: "isOk".to_string(),
method_id: None,
args: vec![],
effects: 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,
})?;
// else: return res_val
self.current_block = Some(else_block);
self.ensure_block_exists(else_block)?;
self.emit_instruction(MirInstruction::Return {
value: Some(res_val),
})?;
// then: getValue()
self.current_block = Some(then_block);
self.ensure_block_exists(then_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(MirInstruction::BoxCall {
dst: Some(val_id),
box_val: res_val,
method: "getValue".to_string(),
method_id: None,
args: vec![],
effects: EffectMask::PURE,
})?;
self.value_types.insert(val_id, super::MirType::Unknown);
Ok(val_id)
}
ASTNode::Print { expression, .. } => self.build_print_statement(*expression.clone()),
ASTNode::Program { statements, .. } => self.build_block(statements.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()),
// P1: Lower peek expression into if-else chain with phi
ASTNode::PeekExpr {
scrutinee,
arms,
else_expr,
..
} => {
// Evaluate scrutinee once
let scr_val = self.build_expression(*scrutinee.clone())?;
// Prepare a merge block and collect phi inputs
let merge_block = self.block_gen.next();
let mut phi_inputs: Vec<(super::BasicBlockId, super::ValueId)> = Vec::new();
// Start chaining from the current block
for (lit, arm_expr) in arms.into_iter() {
// Build condition: scr_val == lit
let lit_id = self.build_literal(lit)?;
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,
})?;
// Create then and next blocks
let then_block = self.block_gen.next();
let next_block = self.block_gen.next();
self.emit_instruction(super::MirInstruction::Branch {
condition: cond_id,
then_bb: then_block,
else_bb: next_block,
})?;
// then: evaluate arm expr, jump to merge
self.current_block = Some(then_block);
self.ensure_block_exists(then_block)?;
let then_val = self.build_expression(arm_expr)?;
if !self.is_current_block_terminated() {
self.emit_instruction(super::MirInstruction::Jump {
target: merge_block,
})?;
}
phi_inputs.push((then_block, then_val));
// else path continues chaining
self.current_block = Some(next_block);
self.ensure_block_exists(next_block)?;
// Loop continues from next_block
}
// Final else branch
let cur_block = self.current_block.ok_or("No current basic block")?;
let else_val = self.build_expression(*else_expr.clone())?;
if !self.is_current_block_terminated() {
self.emit_instruction(super::MirInstruction::Jump {
target: merge_block,
})?;
}
phi_inputs.push((cur_block, else_val));
// Merge and phi
self.current_block = Some(merge_block);
self.ensure_block_exists(merge_block)?;
let result_val = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Phi {
dst: result_val,
inputs: phi_inputs,
})?;
Ok(result_val)
}
ASTNode::Lambda { params, body, .. } => {
// Lambda→FunctionBox 値 Lower（最小 + 簡易キャプチャ解析）
let dst = self.value_gen.next();
// Collect free variable names: variables used in body but not in params, and not 'me'/'this'
use std::collections::HashSet;
let mut used: HashSet<String> = HashSet::new();
let mut locals: HashSet<String> = HashSet::new();
for p in params.iter() {
locals.insert(p.clone());
}
for st in body.iter() {
vars::collect_free_vars(st, &mut used, &mut locals);
}
// Materialize captures from current variable_map if known
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));
}
}
// me capture（存在すれば）
let me = self.variable_map.get("me").copied();
self.emit_instruction(MirInstruction::FunctionNew {
dst,
params: params.clone(),
body: body.clone(),
captures,
me,
})?;
self.value_types
.insert(dst, super::MirType::Box("FunctionBox".to_string()));
Ok(dst)
}
ASTNode::Return { value, .. } => self.build_return_statement(value.clone()),
ASTNode::Local {
variables,
initial_values,
..
} => self.build_local_statement(variables.clone(), initial_values.clone()),
ASTNode::BoxDeclaration {
name,
methods,
is_static,
fields,
constructors,
weak_fields,
..
} => {
if is_static && name == "Main" {
self.build_static_main_box(name.clone(), methods.clone())
} else {
// Support user-defined boxes - handle as statement, return void
// Track as user-defined (eligible for method lowering)
self.user_defined_boxes.insert(name.clone());
self.build_box_declaration(
name.clone(),
methods.clone(),
fields.clone(),
weak_fields.clone(),
)?;
// Phase 2: Lower constructors (birth/N) into MIR functions
// Function name pattern: "{BoxName}.{constructor_key}" (e.g., "Person.birth/1")
for (ctor_key, ctor_ast) in constructors.clone() {
if let ASTNode::FunctionDeclaration { params, body, .. } = ctor_ast {
let func_name = format!("{}.{}", name, ctor_key);
self.lower_method_as_function(
func_name,
name.clone(),
params.clone(),
body.clone(),
)?;
}
}
// Phase 3: Lower instance methods into MIR functions
// Function name pattern: "{BoxName}.{method}/{N}"
for (method_name, method_ast) in methods.clone() {
if let ASTNode::FunctionDeclaration {
params,
body,
is_static,
..
} = method_ast
{
if !is_static {
let func_name = format!(
"{}.{}{}",
name,
method_name,
format!("/{}", params.len())
);
self.lower_method_as_function(
func_name,
name.clone(),
params.clone(),
body.clone(),
)?;
}
}
}
// Return a void value since this is a statement
let void_val = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: void_val,
value: ConstValue::Void,
})?;
Ok(void_val)
}
}
ASTNode::FieldAccess { object, field, .. } => {
self.build_field_access(*object.clone(), field.clone())
}
ASTNode::New {
class, arguments, ..
} => self.build_new_expression(class.clone(), arguments.clone()),
ASTNode::ArrayLiteral { elements, .. } => {
// Lower: new ArrayBox(); for each elem: .push(elem)
let arr_id = self.value_gen.next();
self.emit_instruction(MirInstruction::NewBox {
dst: arr_id,
box_type: "ArrayBox".to_string(),
args: vec![],
})?;
for e in elements {
let v = self.build_expression(e)?;
self.emit_instruction(MirInstruction::BoxCall {
dst: None,
box_val: arr_id,
method: "push".to_string(),
method_id: None,
args: vec![v],
effects: super::EffectMask::MUT,
})?;
}
Ok(arr_id)
}
// Phase 7: Async operations
ASTNode::Nowait {
variable,
expression,
..
} => self.build_nowait_statement(variable.clone(), *expression.clone()),
ASTNode::AwaitExpression { expression, .. } => {
self.build_await_expression(*expression.clone())
}
ASTNode::Include { filename, .. } => {
// Resolve and read included file
let mut path = 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");
}
// Cycle detection
if self.include_loading.contains(&path) {
return Err(format!("Circular include detected: {}", path));
}
// Cache hit: build only the instance
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 = fs::read_to_string(&path)
.map_err(|e| format!("Include read error '{}': {}", filename, e))?;
// Parse to AST
let included_ast = crate::parser::NyashParser::parse_from_string(&content)
.map_err(|e| format!("Include parse error '{}': {:?}", filename, e))?;
// Find first static box name
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))?;
// Lower included AST into current MIR (register types/methods)
let _ = self.build_expression(included_ast)?;
// Mark caches
self.include_loading.remove(&path);
self.include_box_map.insert(path.clone(), bname.clone());
// Return a new instance of included box (no args)
self.build_new_expression(bname, vec![])
}
_ => Err(format!("Unsupported AST node type: {:?}", ast)),
}
}
*/
// build_expression_impl_legacy moved to builder/exprs_legacy.rs (legacy body removed)
/// Build a literal value
pub(super) fn build_literal(&mut self, literal: LiteralValue) -> Result<ValueId, String> {
@ -1065,88 +553,4 @@ impl Default for MirBuilder {
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::{ASTNode, LiteralValue, Span};
#[test]
fn test_literal_building() {
let mut builder = MirBuilder::new();
let ast = ASTNode::Literal {
value: LiteralValue::Integer(42),
span: Span::unknown(),
};
let result = builder.build_module(ast);
assert!(result.is_ok());
let module = result.unwrap();
assert_eq!(module.function_names().len(), 1);
assert!(module.get_function("main").is_some());
}
#[test]
fn test_binary_op_building() {
let mut builder = MirBuilder::new();
let ast = ASTNode::BinaryOp {
left: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(10),
span: Span::unknown(),
}),
operator: BinaryOperator::Add,
right: Box::new(ASTNode::Literal {
value: LiteralValue::Integer(32),
span: Span::unknown(),
}),
span: Span::unknown(),
};
let result = builder.build_module(ast);
assert!(result.is_ok());
let module = result.unwrap();
let function = module.get_function("main").unwrap();
// Should have constants and binary operation
let stats = function.stats();
assert!(stats.instruction_count >= 3); // 2 constants + 1 binop + 1 return
}
#[test]
fn test_if_statement_building() {
let mut builder = MirBuilder::new();
// Adapt test to current AST: If with statement bodies
let ast = ASTNode::If {
condition: Box::new(ASTNode::Literal {
value: LiteralValue::Bool(true),
span: Span::unknown(),
}),
then_body: vec![ASTNode::Literal {
value: LiteralValue::Integer(1),
span: Span::unknown(),
}],
else_body: Some(vec![ASTNode::Literal {
value: LiteralValue::Integer(2),
span: Span::unknown(),
}]),
span: Span::unknown(),
};
let result = builder.build_module(ast);
assert!(result.is_ok());
let module = result.unwrap();
let function = module.get_function("main").unwrap();
// Should have multiple blocks for if/then/else/merge
assert!(function.blocks.len() >= 3);
// Should have phi function in merge block
let stats = function.stats();
assert!(stats.phi_count >= 1);
}
}
// Unit tests moved to `tests/mir_builder_unit.rs` to keep this file lean