Files
marqdo/src/bytecode/vm.rs
T
cflmyandCursor 88dc6d5a54 feat(core): Artifact Metadata Binding (${env|arg|sys|secret})
Load-time resolve of frontmatter bindings into Module.metadata; Secret
masking; sys.meta / --bind; llm ctor prefers meta over env_get.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-24 19:51:24 +08:00

785 lines
34 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Stack VM for Marqdo bytecode.
use anyhow::Result;
use std::io::Write;
use std::path::{Path, PathBuf};
use crate::builtin::{
builtin_at, builtin_footnote_get, builtin_int, builtin_iter_items, builtin_join,
builtin_len, builtin_split, builtin_str, builtin_trim,
builtin_type,
};
use crate::host::{call_host, HostContext, HostFn};
use crate::bytecode::{Op, Program};
use crate::debug::emit_trace;
use crate::diagnostics::{bail_at, Span};
use crate::input_feed::InputFeed;
use crate::value::Value;
use std::collections::HashMap;
pub struct Vm {
path: Option<PathBuf>,
capture: bool,
pub captured_stdout: String,
input: InputFeed,
trace: bool,
host: HostContext,
}
struct Frame {
fn_idx: usize,
ip: usize,
slots: Vec<Value>,
/// When set, retag matrix-like return to this `_type` (method chaining).
retag_matrix: Option<String>,
}
impl Vm {
pub fn new(path: Option<&Path>) -> Self {
Self {
path: path.map(|p| p.to_path_buf()),
capture: false,
captured_stdout: String::new(),
input: InputFeed::new(false, Vec::new()),
trace: false,
host: HostContext::for_run(path, Default::default(), Vec::new()),
}
}
pub fn with_capture(path: Option<&Path>) -> Self {
Self {
path: path.map(|p| p.to_path_buf()),
capture: true,
captured_stdout: String::new(),
input: InputFeed::new(true, Vec::new()),
trace: false,
host: HostContext::for_capture(path, Default::default()),
}
}
pub fn with_stdin(mut self, lines: Vec<String>) -> Self {
self.input = InputFeed::new(self.capture, lines);
self
}
pub fn with_trace(mut self, trace: bool) -> Self {
self.trace = trace;
self
}
pub fn with_host(mut self, host: HostContext) -> Self {
self.host = host;
self
}
pub fn take_plots(&mut self) -> Vec<crate::host::PlotArtifact> {
std::mem::take(&mut self.host.plots)
}
fn emit_line(&mut self, text: &str) {
if self.capture {
self.captured_stdout.push_str(text);
self.captured_stdout.push('\n');
} else {
println!("{text}");
}
}
fn emit_prompt(&mut self, prompt: &str) {
if prompt.is_empty() {
return;
}
if self.capture {
self.captured_stdout.push_str(prompt);
} else {
print!("{prompt}");
let _ = std::io::stdout().flush();
}
}
fn err_at(&self, span: Span, message: impl Into<String>) -> anyhow::Error {
bail_at(self.path.as_deref(), span, message)
}
pub fn run(&mut self, program: &Program) -> Result<Value> {
let mut stack: Vec<Value> = Vec::new();
let entry = program.entry;
let arity = program.functions[entry].params.len();
if arity != 0 {
let span = program.functions[entry]
.spans
.first()
.copied()
.unwrap_or(Span::new(1, 1));
return Err(self.err_at(span, "bytecode: entry function needs arguments"));
}
let mut frames = vec![Frame {
fn_idx: entry,
ip: 0,
slots: vec![Value::None; program.functions[entry].locals.len().max(1)],
retag_matrix: None,
}];
self.host
.push_call_frame(&program.functions[entry].name.clone());
loop {
let frame = frames.last_mut().unwrap();
let fun = &program.functions[frame.fn_idx];
if frame.ip >= fun.code.len() {
let span = fun.spans.last().copied().unwrap_or(Span::new(1, 1));
return Err(self.err_at(span, format!("bytecode: ip out of range in {}", fun.name)));
}
let ip = frame.ip;
let op = fun.code[ip];
let span = fun.spans.get(ip).copied().unwrap_or(Span::new(1, 1));
frame.ip += 1;
self.host.current_line = span.line;
if self.trace {
match op {
Op::Print | Op::Input | Op::Call(_, _) | Op::Return => {
let kind = match op {
Op::Print => "print",
Op::Input => "input",
Op::Call(_, _) => "call",
Op::Return => "return",
_ => unreachable!(),
};
let ip_s = ip.to_string();
emit_trace(
self.path.as_deref(),
Some(span),
"op",
&[
("kind", kind),
("fn", fun.name.as_str()),
("ip", ip_s.as_str()),
],
);
}
_ => {}
}
}
match op {
Op::Constant(i) => stack.push(fun.constants[i as usize].clone()),
Op::True => stack.push(Value::Bool(true)),
Op::False => stack.push(Value::Bool(false)),
Op::None_ => stack.push(Value::None),
Op::Pop => {
stack.pop();
}
Op::GetLocal(i) => {
let v = frames.last().unwrap().slots[i as usize].clone();
stack.push(v);
}
Op::SetLocal(i) => {
let v = stack.last().cloned().unwrap_or(Value::None);
let slot = i as usize;
let fr = frames.last_mut().unwrap();
if fr.slots.len() <= slot {
fr.slots.resize(slot + 1, Value::None);
}
fr.slots[slot] = v;
}
Op::Add => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
if let Some(v) = crate::linalg_ops::try_matrix_binary(
&mut self.host,
crate::ast::BinaryOp::Add,
&a,
&b,
)
.map_err(|m| self.err_at(span, m))?
{
stack.push(v);
} else {
stack.push(add(a, b).map_err(|m| self.err_at(span, m))?);
}
}
Op::Sub => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
if let Some(v) = crate::linalg_ops::try_matrix_binary(
&mut self.host,
crate::ast::BinaryOp::Sub,
&a,
&b,
)
.map_err(|m| self.err_at(span, m))?
{
stack.push(v);
} else {
match (a, b) {
(Value::Int(x), Value::Int(y)) => stack.push(Value::Int(x - y)),
(Value::Num(x), Value::Num(y)) => stack.push(Value::Num(x - y)),
(Value::Int(x), Value::Num(y)) => {
stack.push(Value::Num(x as f64 - y))
}
(Value::Num(x), Value::Int(y)) => {
stack.push(Value::Num(x - y as f64))
}
_ => return Err(self.err_at(span, "`-` needs ints or nums")),
}
}
}
Op::Mul => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
if let Some(v) = crate::linalg_ops::try_matrix_binary(
&mut self.host,
crate::ast::BinaryOp::Mul,
&a,
&b,
)
.map_err(|m| self.err_at(span, m))?
{
stack.push(v);
} else {
match (a, b) {
(Value::Int(x), Value::Int(y)) => stack.push(Value::Int(x * y)),
(Value::Num(x), Value::Num(y)) => stack.push(Value::Num(x * y)),
(Value::Int(x), Value::Num(y)) => {
stack.push(Value::Num(x as f64 * y))
}
(Value::Num(x), Value::Int(y)) => {
stack.push(Value::Num(x * y as f64))
}
_ => return Err(self.err_at(span, "`*` needs ints or nums")),
}
}
}
Op::Div => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
match (a, b) {
(Value::Int(_), Value::Int(0)) => {
return Err(self.err_at(span, "division by zero"));
}
(Value::Int(x), Value::Int(y)) => stack.push(Value::Int(x / y)),
(Value::Num(_), Value::Num(y)) if y == 0.0 => {
return Err(self.err_at(span, "division by zero"));
}
(Value::Int(_), Value::Num(y)) if y == 0.0 => {
return Err(self.err_at(span, "division by zero"));
}
(Value::Num(_), Value::Int(0)) => {
return Err(self.err_at(span, "division by zero"));
}
(Value::Num(x), Value::Num(y)) => stack.push(Value::Num(x / y)),
(Value::Int(x), Value::Num(y)) => {
stack.push(Value::Num(x as f64 / y))
}
(Value::Num(x), Value::Int(y)) => {
stack.push(Value::Num(x / y as f64))
}
_ => return Err(self.err_at(span, "`/` needs ints or nums")),
}
}
Op::Negate => match pop(&mut stack).map_err(|m| self.err_at(span, m))? {
Value::Int(n) => stack.push(Value::Int(-n)),
Value::Num(n) => stack.push(Value::Num(-n)),
_ => return Err(self.err_at(span, "unary `-` needs int or num")),
},
Op::Not => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(Value::Bool(!v.truthy()));
}
Op::Equal => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(Value::Bool(a == b));
}
Op::NotEqual => {
let b = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let a = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(Value::Bool(a != b));
}
Op::Greater => cmp(&mut stack, |o| o.is_gt()).map_err(|m| self.err_at(span, m))?,
Op::GreaterEqual => {
cmp(&mut stack, |o| o.is_ge()).map_err(|m| self.err_at(span, m))?
}
Op::Less => cmp(&mut stack, |o| o.is_lt()).map_err(|m| self.err_at(span, m))?,
Op::Lessequal => cmp(&mut stack, |o| o.is_le()).map_err(|m| self.err_at(span, m))?,
Op::Jump(t) => {
frames.last_mut().unwrap().ip = t as usize;
}
Op::JumpIfFalse(t) => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
if !v.truthy() {
frames.last_mut().unwrap().ip = t as usize;
}
}
Op::Print => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
self.emit_line(&v.as_display());
}
Op::Input => {
let prompt = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let text = prompt.as_display();
let line = if self.capture {
self.emit_prompt(&text);
self.input.read_line()
} else if crate::input_feed::stdin_is_tty() {
self.input
.read_line_with_prompt(&text)
.map(|(line, _)| line)
} else {
self.emit_prompt(&text);
self.input.read_line()
}
.map_err(|e| {
let msg = e.to_string();
if msg.contains("input needs a line") {
self.err_at(span, msg)
} else {
e
}
})?;
stack.push(Value::Text(line));
}
Op::BuildList(n) => {
let n = n as usize;
let mut items = Vec::with_capacity(n);
for _ in 0..n {
items.push(pop(&mut stack).map_err(|m| self.err_at(span, m))?);
}
items.reverse();
stack.push(Value::List(items));
}
Op::BuildMap(n) => {
let n = n as usize;
let mut pairs = Vec::with_capacity(n);
for _ in 0..n {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let k = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let ks = match k {
Value::Text(s) => s,
_ => {
return Err(self.err_at(span, "map key must be text"));
}
};
pairs.push((ks, v));
}
pairs.reverse();
stack.push(Value::Map(pairs));
}
Op::Len => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let n = builtin_len(&v).map_err(|m| self.err_at(span, m))?;
stack.push(Value::Int(n));
}
Op::Str => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_str(&v));
}
Op::Int => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let n = builtin_int(&v).map_err(|m| self.err_at(span, m))?;
stack.push(Value::Int(n));
}
Op::TypeOf => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_type(&v));
}
Op::Trim => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_trim(&v).map_err(|m| self.err_at(span, m))?);
}
Op::Split => {
let sep = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let value = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_split(&value, &sep).map_err(|m| self.err_at(span, m))?);
}
Op::Join => {
let sep = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let value = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_join(&value, &sep).map_err(|m| self.err_at(span, m))?);
}
Op::GetIndex => {
let idx = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let list = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_at(&list, &idx).map_err(|m| self.err_at(span, m))?);
}
Op::IterItems => {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(builtin_iter_items(&v).map_err(|m| self.err_at(span, m))?);
}
Op::FootnoteGet => {
let label = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let base = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let label = match label {
Value::Text(s) => s,
_ => {
return Err(self.err_at(span, "footnote label must be text"));
}
};
stack.push(
builtin_footnote_get(&base, &label).map_err(|m| self.err_at(span, m))?,
);
}
Op::HostCall(id, argc) => {
let hf = HostFn::from_u16(id)
.ok_or_else(|| self.err_at(span, format!("unknown host id {id}")))?;
let argc = argc as usize;
let params = hf.all_params();
if params.len() != argc {
return Err(self.err_at(span, "host call argc mismatch"));
}
let mut vals = Vec::with_capacity(argc);
for _ in 0..argc {
vals.push(pop(&mut stack).map_err(|m| self.err_at(span, m))?);
}
vals.reverse();
let mut bound = HashMap::new();
for (p, v) in params.iter().zip(vals.into_iter()) {
bound.insert((*p).to_string(), v);
}
for req in hf.required_params() {
if !bound.contains_key(*req) {
return Err(self.err_at(
span,
format!("{} requires `{req}`", hf.name()),
));
}
}
let result =
call_host(&mut self.host, hf, &bound).map_err(|m| self.err_at(span, m))?;
stack.push(result);
}
Op::Call(fid, argc) => {
let fid = fid as usize;
let argc = argc as usize;
let callee = &program.functions[fid];
if callee.params.len() != argc {
return Err(self.err_at(span, "call argument count mismatch"));
}
let mut slots = vec![Value::None; callee.locals.len().max(argc).max(1)];
for i in (0..argc).rev() {
slots[i] = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
}
let fname = program.functions[fid].name.clone();
frames.push(Frame {
fn_idx: fid,
ip: 0,
slots,
retag_matrix: None,
});
self.host.push_call_frame(&fname);
self.host.push_call_site_line(span.line);
}
Op::TagInstance(idx) => {
let type_name = match fun.constants.get(idx as usize) {
Some(Value::Text(s)) => s.clone(),
_ => {
return Err(self.err_at(span, "TagInstance needs type name constant"));
}
};
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
stack.push(tag_instance_value(&type_name, v));
}
Op::MethodCall(name_idx, argc) => {
let argc = argc as usize;
let method_name = match fun.constants.get(name_idx as usize) {
Some(Value::Text(s)) => s.clone(),
_ => {
return Err(self.err_at(span, "MethodCall needs method name constant"));
}
};
let recv = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let mut vals = Vec::with_capacity(argc);
for _ in 0..argc {
vals.push(pop(&mut stack).map_err(|m| self.err_at(span, m))?);
}
vals.reverse();
let type_name = instance_type_name_bc(&recv).map_err(|m| self.err_at(span, m))?;
let start_oi = program
.objects
.iter()
.position(|(n, _)| n == &type_name)
.ok_or_else(|| {
self.err_at(span, format!("unknown object type `{type_name}`"))
})?;
let method_fid = resolve_method_fid(program, start_oi, &method_name).ok_or_else(
|| {
let mut chain = Vec::new();
let mut oi = Some(start_oi);
let mut seen = std::collections::HashSet::new();
while let Some(i) = oi {
if !seen.insert(i) {
break;
}
chain.push(program.objects[i].0.as_str());
oi = program.object_bases.get(i).copied().flatten().and_then(
|base_flat| {
program.objects.iter().position(|(_, f)| *f == base_flat)
},
);
}
self.err_at(
span,
format!(
"unknown method `{type_name}.{method_name}` (searched {})",
chain.join(" → ")
),
)
},
)?;
let callee = &program.functions[method_fid];
if callee.params.len() != argc {
return Err(self.err_at(span, "method argument count mismatch"));
}
let mut slots = vec![Value::None; callee.locals.len().max(1)];
for (i, v) in vals.into_iter().enumerate() {
slots[i] = v;
}
for (i, name) in callee.locals.iter().enumerate() {
if name == "自" || name == "self" {
slots[i] = recv.clone();
}
}
let retag_matrix = if crate::linalg_ops::is_matrix_value(&recv) {
Some(type_name.clone())
} else {
None
};
let fname = callee.name.clone();
frames.push(Frame {
fn_idx: method_fid,
ip: 0,
slots,
retag_matrix,
});
self.host.push_call_frame(&fname);
self.host.push_call_site_line(span.line);
}
Op::PluginCall(name_idx, argc) => {
let argc = argc as usize;
let raw_name = match fun.constants.get(name_idx as usize) {
Some(Value::Text(s)) => s.clone(),
_ => {
return Err(self.err_at(span, "PluginCall needs name constant"));
}
};
let mut bound = HashMap::new();
if let Some(name) = raw_name.strip_prefix('@') {
// named pairs: (name, value) × N, argc = 2N
if argc % 2 != 0 {
return Err(self.err_at(span, "PluginCall named argc must be even"));
}
let pairs = argc / 2;
for _ in 0..pairs {
let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let k = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let ks = match k {
Value::Text(s) => s,
_ => {
return Err(self.err_at(span, "plugin arg name must be text"));
}
};
bound.insert(ks, v);
}
let result =
crate::host::plugin::call_registered(&mut self.host, name, &bound)
.map_err(|m| self.err_at(span, m))?;
stack.push(result);
} else {
let mut vals = Vec::with_capacity(argc);
for _ in 0..argc {
vals.push(pop(&mut stack).map_err(|m| self.err_at(span, m))?);
}
vals.reverse();
let reg = self
.host
.plugins
.get(&raw_name)
.cloned()
.ok_or_else(|| {
self.err_at(span, format!("unknown function `{raw_name}`"))
})?;
if reg.params.len() != vals.len() {
return Err(self.err_at(
span,
format!(
"plugin `{raw_name}` expects {} args, got {}",
reg.params.len(),
vals.len()
),
));
}
for (p, v) in reg.params.iter().zip(vals.into_iter()) {
bound.insert(p.clone(), v);
}
let result =
crate::host::plugin::call_registered(&mut self.host, &raw_name, &bound)
.map_err(|m| self.err_at(span, m))?;
stack.push(result);
}
}
Op::CallFn => {
let name_v = pop(&mut stack).map_err(|m| self.err_at(span, m))?;
let name = match name_v {
Value::Text(s) => s,
_ => return Err(self.err_at(span, "call_fn requires text name")),
};
let current = frames.last().unwrap().fn_idx;
let fid = resolve_fn_dynamic(program, current, &name)
.map_err(|m| self.err_at(span, m))?;
let callee = &program.functions[fid];
if !callee.params.is_empty() {
return Err(self.err_at(
span,
format!("call_fn: `{name}` must have no parameters"),
));
}
let slots = vec![Value::None; callee.locals.len().max(1)];
let fname = callee.name.clone();
frames.push(Frame {
fn_idx: fid,
ip: 0,
slots,
retag_matrix: None,
});
self.host.push_call_frame(&fname);
self.host.push_call_site_line(span.line);
}
Op::Return => {
let ret = pop(&mut stack).unwrap_or(Value::None);
let frame = frames.pop();
self.host.pop_call_frame();
self.host.pop_call_site_line();
let ret = match frame.and_then(|f| f.retag_matrix) {
Some(ty) => crate::linalg_ops::retag_matrix_like(&ty, ret),
None => ret,
};
if frames.is_empty() {
return Ok(ret);
}
stack.push(ret);
}
}
}
}
}
fn resolve_method_fid(program: &Program, start_oi: usize, method_name: &str) -> Option<usize> {
let mut oi = Some(start_oi);
let mut seen = std::collections::HashSet::new();
while let Some(i) = oi {
if !seen.insert(i) {
break;
}
let obj_flat = program.objects[i].1;
if let Some((_, _, fid)) = program
.methods
.iter()
.find(|(o, m, _)| *o == obj_flat && m == method_name)
{
return Some(*fid);
}
oi = program.object_bases.get(i).copied().flatten().and_then(|base_flat| {
program.objects.iter().position(|(_, f)| *f == base_flat)
});
}
None
}
fn pop(stack: &mut Vec<Value>) -> Result<Value, String> {
stack
.pop()
.ok_or_else(|| "bytecode: stack underflow".to_string())
}
fn add(a: Value, b: Value) -> Result<Value, String> {
match (a, b) {
(Value::Int(x), Value::Int(y)) => Ok(Value::Int(x + y)),
(Value::Num(x), Value::Num(y)) => Ok(Value::Num(x + y)),
(Value::Int(x), Value::Num(y)) => Ok(Value::Num(x as f64 + y)),
(Value::Num(x), Value::Int(y)) => Ok(Value::Num(x + y as f64)),
(Value::Text(x), Value::Text(y)) => Ok(Value::Text(format!("{x}{y}"))),
(Value::Text(x), Value::Secret(y)) => Ok(Value::Text(format!("{x}{y}"))),
(Value::Secret(x), Value::Text(y)) => Ok(Value::Text(format!("{x}{y}"))),
(Value::Secret(x), Value::Secret(y)) => Ok(Value::Text(format!("{x}{y}"))),
(Value::Text(x), y) => Ok(Value::Text(format!("{x}{}", y.as_display()))),
(x, Value::Text(y)) => Ok(Value::Text(format!("{}{y}", x.as_display()))),
(Value::Int(x), y) => Ok(Value::Text(format!("{}{}", x, y.as_display()))),
(x, Value::Int(y)) => Ok(Value::Text(format!("{}{y}", x.as_display()))),
_ => Err("`+` needs ints, nums, or text".into()),
}
}
fn cmp(stack: &mut Vec<Value>, pred: impl Fn(std::cmp::Ordering) -> bool) -> Result<(), String> {
let b = pop(stack)?;
let a = pop(stack)?;
let ord = match (&a, &b) {
(Value::Int(x), Value::Int(y)) => x.cmp(y),
(Value::Num(x), Value::Num(y)) => x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal),
(Value::Int(x), Value::Num(y)) => {
(*x as f64).partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal)
}
(Value::Num(x), Value::Int(y)) => {
x.partial_cmp(&(*y as f64)).unwrap_or(std::cmp::Ordering::Equal)
}
(Value::Text(x), Value::Text(y)) => x.cmp(y),
_ => return Err("comparison needs two ints/nums or two texts".into()),
};
stack.push(Value::Bool(pred(ord)));
Ok(())
}
fn instance_type_name_bc(v: &Value) -> Result<String, String> {
match v {
Value::Map(entries) => entries
.iter()
.find(|(k, _)| k == "_type")
.and_then(|(_, v)| match v {
Value::Text(s) => Some(s.clone()),
_ => None,
})
.ok_or_else(|| "method receiver needs a map with `_type`".into()),
_ => Err("method receiver must be an object map".into()),
}
}
fn tag_instance_value(type_name: &str, value: Value) -> Value {
match value {
Value::Map(mut entries) => {
// Always stamp the constructed type so an explicit `` `self` = > Parent ``
// inside a child constructor still yields the most specific `_type`.
entries.retain(|(k, _)| k != "_type");
entries.insert(0, ("_type".into(), Value::Text(type_name.into())));
Value::Map(entries)
}
Value::None => Value::Map(vec![("_type".into(), Value::Text(type_name.into()))]),
other => Value::Map(vec![
("_type".into(), Value::Text(type_name.into())),
("value".into(), other),
]),
}
}
fn resolve_fn_dynamic(program: &Program, current: usize, name: &str) -> Result<usize, String> {
for &cid in &program.children[current] {
if program.functions[cid].name == name {
return Ok(cid);
}
}
let mut parent = program.parents[current];
while let Some(pid) = parent {
for &cid in &program.children[pid] {
if program.functions[cid].name == name {
return Ok(cid);
}
}
parent = program.parents[pid];
}
for (i, f) in program.functions.iter().enumerate() {
if program.parents[i].is_none() && f.name == name {
return Ok(i);
}
}
Err(format!("call_fn: unknown function `{name}`"))
}