//! AST → bytecode Program. use anyhow::{bail, Result}; use std::collections::HashMap; use std::path::Path; use crate::ast::{ Arg, BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Param, Stmt, UnaryOp, }; use crate::bytecode::{FnChunk, Op, Program}; use crate::diagnostics::{bail_at, Span}; use crate::value::Value; struct FlatFun<'m> { owner: &'m Module, definition: &'m Function, source: crate::diagnostics::SourceIdentity, module_path: Vec, name: String, level: u8, /// Receiver-free children of an object are associated functions, not /// instance methods. This flag is computed from executable AST only. uses_receiver: bool, parent: Option, /// Inheritance base type name (`# Child = > Parent`), objects only. base: Option, params: Vec, contract: Option, var_contracts: HashMap, body: Vec, children: Vec, span: Span, /// Full path segments (`lib.member` / `lib.Type.method`) → flat index. path_index: HashMap, usize>, /// Short name from frontmatter `use` → path segments. uses: HashMap>, /// Module collection scope (G02): bare-name resolve must not cross imports. scope: u32, } pub fn compile_module(path: Option<&Path>, module: &Module) -> Result { compile_with(path, module, true) } /// Compile every function even when the file has no single program entry. /// `Program::entry` is then only a placeholder; callers must use [`Vm::call_function`]. pub fn compile_for_call(path: Option<&Path>, module: &Module) -> Result { compile_with(path, module, false) } fn compile_with(path: Option<&Path>, module: &Module, require_entry: bool) -> Result { crate::ast::validate_parameters(module)?; let mut flat = Vec::new(); let mut next_scope = 1u32; let _exports = collect_module_tree(module, &mut flat, 0, &mut next_scope, &[]); for fun in &mut flat { if fun.scope == 0 && fun.source.path.is_none() { fun.source.path = path.map(Path::to_path_buf); } } if flat.is_empty() { bail!("bytecode: no functions to compile"); } let chosen = flat .iter() .position(|f| f.scope == 0 && f.name == "main" && f.parent.is_none()) .or_else(|| { let tops: Vec = flat .iter() .enumerate() .filter(|(_, f)| f.scope == 0 && f.parent.is_none() && f.level == 1 && f.params.is_empty()) .map(|(i, _)| i) .collect(); if tops.len() == 1 { Some(tops[0]) } else { None } }); let entry = match chosen { Some(index) => index, None if !require_entry => 0, None => bail!("bytecode: no `# main` object"), }; // Imports are compiled first, so a missing entry must take paths from the file's own functions. let path_owner = if chosen.is_some() { entry } else { flat.len() - 1 }; let mut objects = Vec::new(); let mut methods = Vec::new(); for (i, f) in flat.iter().enumerate() { if f.parent.is_none() && f.level == 1 { objects.push((f.name.clone(), i)); for &cid in &f.children { methods.push((i, flat[cid].name.clone(), cid)); } } } let mut object_bases = Vec::with_capacity(objects.len()); for (_, flat_i) in &objects { let owner = &flat[*flat_i]; let base = if let Some(base) = &owner.base { let path = owner.uses.get(base).cloned().unwrap_or_else(|| vec![base.clone()]); let (name, prefix) = path.split_last().expect("base path"); let mut wanted = owner.module_path.clone(); wanted.extend_from_slice(prefix); let local = objects.iter().find(|(n,id)| n == name && flat[*id].module_path == wanted).map(|(_,id)| *id); if local.is_some() || !prefix.is_empty() { local } else { let candidates = objects.iter().filter(|(n,id)| n == name && flat[*id].module_path.starts_with(&owner.module_path)).map(|(_,id)| *id).collect::>(); if candidates.len() == 1 { Some(candidates[0]) } else { None } } } else { None }; object_bases.push(base); } let mut functions = Vec::new(); for i in 0..flat.len() { let meta = if i == entry { Some(module.metadata.as_slice()) } else { None }; let compiled = compile_function(i, &flat, flat[i].source.path.as_deref(), meta).map_err(|error| { if let Some(diagnostic) = crate::diagnostics::Diagnostic::find(&error).cloned() { anyhow::Error::new(diagnostic.with_source(&flat[i].source)) } else { error } })?; functions.push(compiled); } let parents: Vec> = flat.iter().map(|f| f.parent).collect(); let children: Vec> = flat.iter().map(|f| f.children.clone()).collect(); let path_index = flat[path_owner].path_index.clone(); let program=Program { entry_metadata: module.metadata.clone(), functions, entry, objects, object_bases, methods, parents, children, path_index, }; program.verify().map_err(|error|anyhow::anyhow!(error))?; Ok(program) } /// Collect `module` and its imports into `flat`. /// Returns relative export paths within this module (e.g. `["parse"]`, `["agent","step"]`). /// /// Each module gets a distinct `scope` id. Bare-name `resolve_call` only searches /// within the caller's scope so imported same-named functions cannot be silently /// selected (BoundCall / G02). Cross-module calls must use `bind.member` paths. fn collect_module_tree<'m>( module: &'m Module, flat: &mut Vec>, scope: u32, next_scope: &mut u32, module_path: &[String], ) -> HashMap, usize> { let mut path_index = HashMap::new(); let mut imports = module.import_modules.iter().collect::>(); imports.sort_by_key(|(name,_)| *name); for (bind, dep) in imports { let child_scope = *next_scope; *next_scope += 1; let mut child_path=module_path.to_vec(); child_path.push(bind.clone()); let dep_exports = collect_module_tree(dep, flat, child_scope, next_scope, &child_path); for (rel, idx) in dep_exports { let mut full = Vec::with_capacity(rel.len() + 1); full.push(bind.clone()); full.extend(rel); path_index.insert(full, idx); } } let uses: HashMap> = module .uses .iter() .map(|u| (u.bind.clone(), u.path.clone())) .collect(); let start = flat.len(); let mut exports = HashMap::new(); for fun in &module.functions { let id = collect_fun(fun, module, None, flat, &path_index, &uses, scope, &module.source, module_path); export_tree(&mut exports, &[], id, flat); } // Same-module BoundCall paths (`Type.member`) must be visible to siblings. for (rel, idx) in &exports { path_index.insert(rel.clone(), *idx); } for f in &mut flat[start..] { if f.scope == scope { for (rel, idx) in &exports { f.path_index.insert(rel.clone(), *idx); } } } exports } fn export_tree( out: &mut HashMap, usize>, prefix: &[String], id: usize, flat: &[FlatFun], ) { let mut p = prefix.to_vec(); p.push(flat[id].name.clone()); out.entry(p.clone()).or_insert(id); for &cid in &flat[id].children { export_tree(out, &p, cid, flat); } } fn collect_fun<'m>( fun: &'m Function, owner: &'m Module, parent: Option, flat: &mut Vec>, path_index: &HashMap, usize>, uses: &HashMap>, scope: u32, source: &crate::diagnostics::SourceIdentity, module_path: &[String], ) -> usize { let id = flat.len(); flat.push(FlatFun { owner, definition: fun, source: source.clone(), module_path: module_path.to_vec(), name: fun.name.clone(), level: fun.level, uses_receiver: crate::ast::function_uses_receiver(fun), parent, base: fun.base.clone(), params: fun.params.clone(), contract: fun.contract.clone(), var_contracts: fun.var_contracts.clone(), body: fun.body.clone(), children: Vec::new(), span: fun.span, path_index: path_index.clone(), uses: uses.clone(), scope, }); let mut child_ids = Vec::new(); for child in &fun.children { child_ids.push(collect_fun( child, owner, Some(id), flat, path_index, uses, scope, source, module_path, )); } flat[id].children = child_ids; id } #[derive(Hash, PartialEq, Eq)] enum ConstantKey { None, Bool(bool), Int(i64), Num(u64), Text(String), } struct FnCompiler<'a> { path: Option<&'a Path>, flat: &'a [FlatFun<'a>], fn_id: usize, chunk: FnChunk, locals: HashMap, stmt_span: Span, call_depth: usize, constant_indices: HashMap, argument_scratch: HashMap<(usize,usize),(String,usize)>, expression_stack: Vec, statement_stack: Vec, call_emission_stack: Vec, } /// Reserve source names before synthesizing scratch names. This covers future /// statements as well as defaults, so even an authored backtick name containing /// the internal prefix cannot alias a temporary. fn reserve_function_names(fun:&FlatFun,locals:&mut HashMap) { fn name(name:&str,locals:&mut HashMap) { if !locals.contains_key(name) { let slot=locals.len();locals.insert(name.into(),slot); } } fn call(call:&CallExpr,locals:&mut HashMap) { if let Some(receiver)=&call.receiver { name(receiver,locals); } if let Some(path)=&call.path { if let Some(first)=path.first() { name(first,locals); } } for arg in &call.args { match arg { Arg::Named{value,..}|Arg::Positional(value)=>expr(value,locals) } } } fn expr(value:&Expr,locals:&mut HashMap) { match value { Expr::Var(value)=>name(value,locals), Expr::Interp(parts)=>for part in parts { match part { InterpPart::Lit(_)=>{}, InterpPart::Var(value)|InterpPart::Index{base:value,..}=>name(value,locals), } }, Expr::Unary{expr:value,..}=>expr(value,locals), Expr::Binary{left,right,..}=>{expr(left,locals);expr(right,locals);}, Expr::Call(value)=>call(value,locals), Expr::List(values)=>for value in values {expr(value,locals);}, Expr::Map(values)=>for (_,value) in values {expr(value,locals);}, Expr::Index{base,label}=>{expr(base,locals);if let crate::ast::IndexKey::Var(value)=label {name(value,locals);}}, Expr::Occluded{payload,..}=>if let Some(value)=payload {expr(value,locals);}, Expr::Literal(_)|Expr::Formula(_)|Expr::Code(_)=>{}, } } fn block(statements:&[Stmt],locals:&mut HashMap) { for statement in statements { match statement { Stmt::Assign{name:key,value,..}=>{name(key,locals);expr(value,locals);}, Stmt::Return{value,..}|Stmt::Expr{value,..}=>expr(value,locals), Stmt::Call{call:value,..}=>call(value,locals), Stmt::Branch{arms,..}=>for arm in arms {if let Some(condition)=&arm.condition {expr(condition,locals);}block(&arm.body,locals);}, Stmt::While{condition,body,..}=>{expr(condition,locals);block(body,locals);}, Stmt::ForEach{item,collection,body,..}=>{name(item,locals);name(collection,locals);block(body,locals);}, } } } for param in &fun.params {if let Some(default)=¶m.default {expr(default,locals);}} block(&fun.body,locals); } fn compile_function( fn_id: usize, flat: &[FlatFun], path: Option<&Path>, metadata: Option<&[(String, Value)]>, ) -> Result { let fun = &flat[fn_id]; let mut locals = HashMap::new(); for (i, p) in fun.params.iter().enumerate() { locals.insert(p.name.clone(), i as usize); } let is_method = fun.uses_receiver; if is_method { for name in ["自", "self"] { if !locals.contains_key(name) { let s = locals.len() as usize; locals.insert(name.to_string(), s); } } } // Phase 2: reserve locals for entry metadata keys before body compile. if let Some(meta) = metadata { for (k, _) in meta { if !locals.contains_key(k) { let s = locals.len() as usize; locals.insert(k.clone(), s); } } } let mut c = FnCompiler { path, flat, fn_id, chunk: FnChunk { source_ast: crate::bytecode::SourceFunction::from_declaration(fun.owner, fun.definition), module_scope: fun.scope, module_path: fun.module_path.clone(), source: fun.source.clone(), declaration_span: fun.span, name: fun.name.clone(), params: fun.params.iter().map(|p| p.name.clone()).collect(), contract: fun.contract.clone(), var_contracts: fun.var_contracts.clone(), receiver_aliases: is_method, defaults: fun.params.iter().map(|p| p.default.is_some()).collect(), default_expressions:vec![None;fun.params.len()], call_layouts: Vec::new(), calls: Vec::new(), source_local_count:0, expressions: Vec::new(), statements: Vec::new(),statement_roots: Vec::new(),body_start:0, code: Vec::new(), spans: Vec::new(), constants: Vec::new(), locals: fun.params.iter().map(|p| p.name.clone()).collect(), }, locals, stmt_span: fun.span, call_depth: 0, constant_indices: HashMap::new(), argument_scratch: HashMap::new(), expression_stack: Vec::new(), statement_stack: Vec::new(), call_emission_stack: Vec::new(), }; reserve_function_names(fun,&mut c.locals); c.chunk.source_local_count=c.locals.len(); // Defaults execute in the declaration's lexical scope and callee frame. // None is a valid supplied value, so omission has a separate presence bit. for (index, param) in fun.params.iter().enumerate() { if let Some(default) = ¶m.default { c.stmt_span=param.span; let jump = c.here(); c.emit(Op::JumpIfProvided(index as usize, 0)); c.chunk.default_expressions[index]=Some(c.chunk.expressions.len()); c.compile_expr(default)?; c.emit(Op::SetLocal(index as usize)); c.emit(Op::Pop); c.patch(jump, Op::JumpIfProvided(index as usize, c.here())); } } c.stmt_span=fun.span; // Metadata is an input to Program::run, not code baked into a function. // Fill only after defaults, so a later omitted default stays unbound while // an earlier default evaluates. c.emit(Op::FillMissingParameters); if fun.contract.is_some() { c.emit(Op::CheckArguments); } if is_method {c.emit(Op::RestoreReceiver);if fun.contract.is_some(){c.emit(Op::CheckFrameArguments);}} c.chunk.body_start=c.here(); for stmt in &fun.body { c.compile_stmt(stmt)?; } c.stmt_span = fun.span; c.emit(Op::None_); c.emit(Op::Return); let mut names = vec![String::new(); c.locals.len()]; for (name, slot) in &c.locals { names[*slot as usize] = name.clone(); } c.chunk.locals = names; debug_assert_eq!(c.chunk.code.len(), c.chunk.spans.len()); Ok(c.chunk) } impl<'a> FnCompiler<'a> { fn err(&self, message: impl Into) -> anyhow::Error { bail_at(self.path, self.stmt_span, message) } fn emit(&mut self, op: Op) { self.chunk.code.push(op); self.chunk.spans.push(self.stmt_span); } fn here(&self) -> usize { self.chunk.code.len() as usize } fn patch(&mut self, at: usize, op: Op) { self.chunk.code[at as usize] = op; } fn add_const(&mut self, v: Value) -> usize { // Index widths follow Vec rather than truncating at 8/16 bits. Scalar // interning is linear overall; float keys preserve their exact bits. let key = match &v { Value::None => Some(ConstantKey::None), Value::Bool(value) => Some(ConstantKey::Bool(*value)), Value::Int(value) => Some(ConstantKey::Int(*value)), Value::Num(value) => Some(ConstantKey::Num(value.to_bits())), Value::Text(value) => Some(ConstantKey::Text(value.clone())), _ => None, }; if let Some(index) = key.as_ref().and_then(|key| self.constant_indices.get(key)) { return *index; } let i = self.chunk.constants.len(); if let Some(key) = key { self.constant_indices.insert(key, i); } self.chunk.constants.push(v); i } fn fresh_slot(&mut self,label:&str)->usize { let mut name=format!("\0{label}.{}",self.locals.len()); while self.locals.contains_key(&name){name.push('\0');} let slot=self.locals.len();self.locals.insert(name,slot);slot } fn local_slot(&mut self, name: &str) -> usize { if let Some(&s) = self.locals.get(name) { return s; } let s = self.locals.len() as usize; self.locals.insert(name.to_string(), s); s } fn compile_stmt(&mut self,stmt:&Stmt)->Result<()> { let id=self.chunk.statements.len();let start=self.here(); self.chunk.statements.push(crate::bytecode::StatementEmission{ rule:crate::bytecode::StatementRule::from_source(stmt),start,end:start, statements:Vec::new(),expressions:Vec::new(),auxiliary:Vec::new(), }); if let Some(parent)=self.statement_stack.last(){self.chunk.statements[*parent].statements.push(id);}else{self.chunk.statement_roots.push(id);} self.statement_stack.push(id);let result=self.compile_stmt_inner(stmt);self.statement_stack.pop(); self.chunk.statements[id].end=self.here();result } fn compile_stmt_inner(&mut self, stmt: &Stmt) -> Result<()> { match stmt { Stmt::Assign { name, value, span, .. } => { self.stmt_span = *span; self.compile_expr(value)?; let slot = self.local_slot(name); if self.chunk.var_contracts.contains_key(name) { self.emit(Op::CheckBinding(slot)); } self.emit(Op::SetLocal(slot)); self.emit(Op::Pop); } Stmt::Return { value, span } => { self.stmt_span = *span; self.compile_expr(value)?; if self.chunk.contract.is_some() { self.emit(Op::CheckReturn); } self.emit(Op::Return); } Stmt::Call { call, span } => { self.stmt_span = *span; self.compile_expr(&Expr::Call(call.clone()))?; self.emit(Op::Pop); } Stmt::Expr { value, span } => { self.stmt_span = *span; self.compile_expr(value)?; self.emit(Op::Pop); } Stmt::Branch { arms, span } => { self.stmt_span = *span; let mut end_jumps = Vec::new(); for (i, arm) in arms.iter().enumerate() { let is_last = i + 1 == arms.len(); let mut else_jump = None; if let Some(cond) = &arm.condition { self.compile_expr(cond)?; let jf = self.here(); self.emit(Op::JumpIfFalse(0)); else_jump = Some(jf); } for st in &arm.body { self.compile_stmt(st)?; } self.stmt_span = *span; if !is_last { let j = self.here(); self.emit(Op::Jump(0)); end_jumps.push(j); } if let Some(jf) = else_jump { self.patch(jf, Op::JumpIfFalse(self.here())); } } let end = self.here(); for j in end_jumps { self.patch(j, Op::Jump(end)); } } Stmt::While { condition, body, span, } => { self.stmt_span = *span; let loop_id=*self.statement_stack.last().unwrap(); self.emit(Op::ResetLoop(loop_id)); let loop_start = self.here(); self.compile_expr(condition)?; let exit_j = self.here(); self.emit(Op::JumpIfFalse(0)); self.emit(Op::CheckLoop(loop_id)); for st in body { self.compile_stmt(st)?; } self.stmt_span = *span; self.emit(Op::Jump(loop_start)); self.patch(exit_j, Op::JumpIfFalse(self.here())); } Stmt::ForEach { item, collection, label: _, body, span, } => { self.stmt_span = *span; self.compile_expr(&Expr::Var(collection.clone()))?; self.emit(Op::IterItems); let coll_slot = self.fresh_slot("loop.collection"); self.emit(Op::SetLocal(coll_slot)); self.emit(Op::Pop); let i_slot = self.fresh_slot("loop.index"); let statement=*self.statement_stack.last().unwrap(); self.chunk.statements[statement].auxiliary=vec![coll_slot,i_slot]; let zero = self.add_const(Value::Int(0)); self.emit(Op::Constant(zero)); self.emit(Op::SetLocal(i_slot)); self.emit(Op::Pop); let item_slot = self.local_slot(item); let loop_start = self.here(); self.emit(Op::GetLocal(i_slot)); self.emit(Op::GetLocal(coll_slot)); self.emit(Op::Len); self.emit(Op::Less); let exit_j = self.here(); self.emit(Op::JumpIfFalse(0)); self.emit(Op::GetLocal(coll_slot)); self.emit(Op::GetLocal(i_slot)); self.emit(Op::GetIndex); self.emit(Op::SetLocal(item_slot)); self.emit(Op::Pop); for st in body { self.compile_stmt(st)?; } self.stmt_span = *span; self.emit(Op::GetLocal(i_slot)); let one = self.add_const(Value::Int(1)); self.emit(Op::Constant(one)); self.emit(Op::Add); self.emit(Op::SetLocal(i_slot)); self.emit(Op::Pop); self.emit(Op::Jump(loop_start)); self.patch(exit_j, Op::JumpIfFalse(self.here())); } } Ok(()) } fn compile_call(&mut self, call: &CallExpr, as_stmt: bool) -> Result<()> { let id=self.chunk.calls.len(); self.chunk.calls.push(crate::bytecode::CallEmission{ expression:*self.expression_stack.last().ok_or_else(||self.err("call has no source expression"))?, source:call.clone(),stages:Vec::new(),dispatch:None,as_statement:as_stmt, }); self.call_emission_stack.push(id); self.call_depth += 1; let result = self.compile_call_inner(call, as_stmt); self.call_depth -= 1; self.call_emission_stack.pop(); result } fn record_dispatch(&mut self, dispatch:crate::bytecode::CallDispatch){ let id=*self.call_emission_stack.last().expect("active call emission"); self.chunk.calls[id].dispatch=Some(dispatch); } fn compile_call_inner(&mut self, call: &CallExpr, as_stmt: bool) -> Result<()> { // Mirror `sema::bind::resolve_for_exec` (G02 BoundCall): // static → Op::Call(fid); dynamic → MethodCall / CallFn / PluginCall. let mut call = call.for_evaluation().map_err(|m| self.err(m))?; let emission=*self.call_emission_stack.last().expect("active call emission"); self.chunk.calls[emission].source=call.clone(); // All actuals run once, left to right, including unused extra named // arguments. Subsequent parameter permutation only reads temporaries. for (index, arg) in call.args.iter_mut().enumerate() { let value = match arg { Arg::Positional(value) => value, Arg::Named { value, .. } => value }; let expression=self.chunk.expressions.len(); self.compile_expr(value)?; let key=(self.call_depth,index); let (name,slot)=if let Some(existing)=self.argument_scratch.get(&key) { existing.clone() } else { let mut name=format!("\0call.arg.{}.{}", self.call_depth, index); while self.locals.contains_key(&name) { name.push('\0'); } let slot = self.locals.len() as usize; self.locals.insert(name.clone(), slot); self.argument_scratch.insert(key,(name.clone(),slot)); (name,slot) }; self.emit(Op::SetLocal(slot)); self.emit(Op::Pop); self.chunk.calls[emission].stages.push(crate::bytecode::CallStage{expression,slot}); *value = Expr::Var(name); } if let Some(recv) = &call.receiver { return self.compile_method_call(recv, &call, as_stmt); } use crate::sema::{ExecTarget, DynamicReason}; let caller=&self.flat[self.fn_id]; let target=crate::sema::resolve_for_exec(caller.owner,caller.definition,&call); let user=match &target { ExecTarget::Local(fun)=>Some((caller.owner,*fun)), ExecTarget::Import{lib,fun,..}=>Some((*lib,*fun)), _=>None, }; let fid=user.map(|(owner,definition)|self.flat.iter().position(|f|std::ptr::eq(f.owner,owner)&&std::ptr::eq(f.definition,definition)) .ok_or_else(||self.err("resolved declaration missing from flat program"))).transpose()?; if let Some(path)=call.path.as_ref().filter(|p|p.len()==2) { let fallback=if let Some(target)=fid { crate::bytecode::PathFallback::User{target,tag_instance:self.flat[target].parent.is_none()&&self.flat[target].level==1} } else { crate::bytecode::PathFallback::Error{message:match target { ExecTarget::Unresolved{message,..}=>message, _=>format!("unresolved dynamic call `{}`",crate::sema::call_display(&call)), }} }; self.record_dispatch(crate::bytecode::CallDispatch::Path{receiver:path[0].clone(),check_receiver:!caller.owner.import_modules.contains_key(&path[0]),fallback}); let layout=self.argument_layout(&call)?; self.emit(Op::PathCallArgs(emission,layout)); if as_stmt{self.emit(Op::Pop);}return Ok(()); } if let Some(fid)=fid{return self.compile_user_call(fid,&call,as_stmt);} match target { ExecTarget::Builtin(_) | ExecTarget::Dynamic{reason:DynamicReason::CallFn,..}=>{ self.record_dispatch(crate::bytecode::CallDispatch::Builtin); let layout=self.argument_layout(&call)?;let name=self.add_const(Value::Text(call.callee.clone())); self.emit(Op::BuiltinCallArgs(name,layout));if as_stmt{self.emit(Op::Pop);}return Ok(()); }, ExecTarget::Host(hf)=>{ self.record_dispatch(crate::bytecode::CallDispatch::Host{function:hf.as_u16()}); let layout=self.argument_layout(&call)?;self.emit(Op::HostCallArgs(hf.as_u16(),layout)); if as_stmt{self.emit(Op::Pop);}return Ok(()); }, ExecTarget::Dynamic{reason:DynamicReason::Plugin,..}=>self.compile_plugin_call(&call,as_stmt), ExecTarget::Unresolved{message,..}=>{ self.record_dispatch(crate::bytecode::CallDispatch::ResolutionFault{message:message.clone()}); let index=self.add_const(Value::Text(message));self.emit(Op::RejectCallResolution(index));Ok(()) }, _=>Err(self.err("unsupported resolved call")), } } fn argument_layout(&mut self, call: &CallExpr) -> Result { let mut layout = Vec::new(); for arg in &call.args { let (name, expr) = match arg { Arg::Positional(expr) => (None, expr), Arg::Named { name, value } => (Some(name.clone()), value), }; self.compile_expr(expr)?; layout.push(name); } let index = self.chunk.call_layouts.len() as usize; self.chunk.call_layouts.push(layout); Ok(index) } fn compile_user_call(&mut self, fid: usize, call: &CallExpr, as_stmt: bool) -> Result<()> { self.record_dispatch(crate::bytecode::CallDispatch::User{target:fid,tag_instance:self.flat[fid].parent.is_none() && self.flat[fid].level==1}); let layout = self.argument_layout(call)?; self.emit(Op::CallArgs(fid as usize, layout)); if self.flat[fid].parent.is_none() && self.flat[fid].level == 1 { self.emit(Op::TagInstance(fid)); } if as_stmt { self.emit(Op::Pop); } Ok(()) } /// Unresolved callee → runtime plugin registry (or unknown-fn error). /// Preserve authored labels until the runtime registry supplies the signature. fn compile_plugin_call(&mut self, call: &CallExpr, as_stmt: bool) -> Result<()> { self.record_dispatch(crate::bytecode::CallDispatch::Plugin); let layout=self.argument_layout(call)?; let name=self.add_const(Value::Text(call.callee.clone())); self.emit(Op::PluginCallArgs(name,layout)); if as_stmt{self.emit(Op::Pop);}Ok(()) } fn compile_method_call(&mut self, recv: &str, call: &CallExpr, as_stmt: bool) -> Result<()> { self.record_dispatch(crate::bytecode::CallDispatch::Method{receiver:recv.into()}); // A method name alone does not determine a signature. Its owner is // selected from the actual receiver before runtime argument binding. let layout = self.argument_layout(call)?; let slot = self.locals.get(recv).copied() .ok_or_else(|| self.err(format!("undefined variable `{recv}`")))?; self.emit(Op::GetLocal(slot)); let name = self.add_const(Value::Text(call.callee.clone())); self.emit(Op::MethodCallArgs(name, layout)); if as_stmt { self.emit(Op::Pop); } Ok(()) } fn compile_expr(&mut self, expr:&Expr)->Result<()> { let id=self.chunk.expressions.len(); let start=self.here(); self.chunk.expressions.push(crate::bytecode::ExpressionEmission{ rule:crate::bytecode::ExpressionRule::from_source(expr),start,end:start,children:Vec::new(), }); if let Some(parent)=self.expression_stack.last(){self.chunk.expressions[*parent].children.push(id);}else if let Some(stmt)=self.statement_stack.last(){self.chunk.statements[*stmt].expressions.push(id);} self.expression_stack.push(id); let result=self.compile_expr_inner(expr); self.expression_stack.pop(); self.chunk.expressions[id].end=self.here(); result } fn compile_expr_inner(&mut self, expr: &Expr) -> Result<()> { match expr { // `` M2: occlusion is transparent for execution — only the // payload runs; the label is diagnosed/rendered, never evaluated. Expr::Occluded { payload, .. } => match payload { Some(inner) => self.compile_expr(inner)?, None => self.emit(Op::None_), }, Expr::Literal(lit) => match lit { Literal::None => self.emit(Op::None_), Literal::Bool(true) => self.emit(Op::True), Literal::Bool(false) => self.emit(Op::False), Literal::Int(n) => { let i = self.add_const(Value::Int(*n)); self.emit(Op::Constant(i)); } Literal::Num(n) => { let i = self.add_const(Value::Num(*n)); self.emit(Op::Constant(i)); } Literal::Text(t) => { let i = self.add_const(Value::Text(t.clone())); self.emit(Op::Constant(i)); } }, Expr::Var(name) => { let slot = self .locals .get(name) .copied() .ok_or_else(|| self.err(format!("undefined variable `{name}`")))?; self.emit(Op::GetLocal(slot)); } Expr::Interp(parts) => { if parts.is_empty() { let i = self.add_const(Value::Text(String::new())); self.emit(Op::Constant(i)); return Ok(()); } for (idx, part) in parts.iter().enumerate() { match part { InterpPart::Lit(t) => { let i = self.add_const(Value::Text(t.clone())); self.emit(Op::Constant(i)); } InterpPart::Var(n) => { let slot = self .locals .get(n) .copied() .ok_or_else(|| self.err(format!("undefined variable `{n}`")))?; self.emit(Op::GetLocal(slot)); } InterpPart::Index { base, labels } => { let slot = self.locals.get(base).copied().ok_or_else(|| { self.err(format!("undefined variable `{base}`")) })?; self.emit(Op::GetLocal(slot)); for label in labels { let li = self.add_const(Value::Text(label.clone())); self.emit(Op::Constant(li)); self.emit(Op::FootnoteGet); } } } self.emit(Op::Str); if idx > 0 { self.emit(Op::Add); } } } Expr::Unary { op, expr } => { self.compile_expr(expr)?; match op { UnaryOp::Not => self.emit(Op::Not), UnaryOp::Neg => self.emit(Op::Negate), } } Expr::Binary { op: BinaryOp::And, left, right, } => { self.compile_expr(left)?; let j_false = self.here(); self.emit(Op::JumpIfFalse(0)); self.compile_expr(right)?; let j_false2 = self.here(); self.emit(Op::JumpIfFalse(0)); self.emit(Op::True); let j_end = self.here(); self.emit(Op::Jump(0)); let f2 = self.here(); self.patch(j_false2, Op::JumpIfFalse(f2)); self.emit(Op::False); let j_end2 = self.here(); self.emit(Op::Jump(0)); let f1 = self.here(); self.patch(j_false, Op::JumpIfFalse(f1)); self.emit(Op::False); let end = self.here(); self.patch(j_end, Op::Jump(end)); self.patch(j_end2, Op::Jump(end)); } Expr::Binary { op: BinaryOp::Or, left, right, } => { self.compile_expr(left)?; let j_else = self.here(); self.emit(Op::JumpIfFalse(0)); self.emit(Op::True); let j_end = self.here(); self.emit(Op::Jump(0)); let else_ip = self.here(); self.patch(j_else, Op::JumpIfFalse(else_ip)); self.compile_expr(right)?; let j_f = self.here(); self.emit(Op::JumpIfFalse(0)); self.emit(Op::True); let j_end2 = self.here(); self.emit(Op::Jump(0)); let f = self.here(); self.patch(j_f, Op::JumpIfFalse(f)); self.emit(Op::False); let end = self.here(); self.patch(j_end, Op::Jump(end)); self.patch(j_end2, Op::Jump(end)); } Expr::Binary { op, left, right } => { self.compile_expr(left)?; self.compile_expr(right)?; self.emit(match op { BinaryOp::Add => Op::Add, BinaryOp::Sub => Op::Sub, BinaryOp::Mul => Op::Mul, BinaryOp::Div => Op::Div, BinaryOp::Eq => Op::Equal, BinaryOp::Ne => Op::NotEqual, BinaryOp::Lt => Op::Less, BinaryOp::Le => Op::Lessequal, BinaryOp::Gt => Op::Greater, BinaryOp::Ge => Op::GreaterEqual, BinaryOp::And | BinaryOp::Or => unreachable!(), }); } Expr::Call(call) => { if let Err(message)=call.for_evaluation(){ let index=self.add_const(Value::Text(message)); self.emit(Op::RejectArgumentExpansion(index)); }else{self.compile_call(call, false)?;} }, Expr::List(items) => { for it in items { self.compile_expr(it)?; } self.emit(Op::BuildList(items.len() as usize)); } Expr::Map(pairs) => { for (k, e) in pairs { let ki = self.add_const(Value::Text(k.clone())); self.emit(Op::Constant(ki)); self.compile_expr(e)?; } self.emit(Op::BuildMap(pairs.len() as usize)); } Expr::Index { base, label } => { self.compile_expr(base)?; match label { crate::ast::IndexKey::Lit(s) => { let li = self.add_const(Value::Text(s.clone())); self.emit(Op::Constant(li)); } crate::ast::IndexKey::Var(name) => { let slot = self.locals.get(name).copied().ok_or_else(|| { self.err(format!("undefined variable `{name}` in footnote key")) })?; self.emit(Op::GetLocal(slot)); self.emit(Op::Str); } } if let Expr::Var(name)=base.as_ref() { if self.chunk.var_contracts.contains_key(name) { self.emit(Op::ContractFootnoteGet(self.locals[name])); } else { self.emit(Op::FootnoteGet); } } else { self.emit(Op::FootnoteGet); } } Expr::Formula(e) => { let i = self.add_const(Value::Formula(e.clone())); self.emit(Op::Constant(i)); } Expr::Code(c) => { let i = self.add_const(Value::Code(c.clone())); self.emit(Op::Constant(i)); } } Ok(()) } }