Files
marqdo/src/interp.rs
T
cflmyandCursor 1730f26fc7 release: v2.2.0 call one function in any .mq.md
The same page is the document, the knowledge and the program. marqdo call runs that function with arguments, so reuse, tools and tests do not need a second skill system.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-30 09:07:23 +08:00

2075 lines
73 KiB
Rust

//! Tree-walk interpreter (Phase I).
use anyhow::{bail, Result};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use crate::ast::{
Arg, BinaryOp, CallExpr, Expr, Function, IndexKey, InterpPart, Literal, Module, Param, Stmt,
UnaryOp,
};
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::debug::{emit_trace, DebugController};
use crate::diagnostics::{bail_at, Span};
use crate::host::{call_host, HostContext};
use crate::input_feed::InputFeed;
use crate::capture::{
BranchHit, CallFrame, LoopFrame, LoopHit, LoopIter, StmtEvent, StmtEventKind, ViewTrace,
};
use crate::value::Value;
use std::sync::Arc;
pub struct Interpreter {
pub path: Option<PathBuf>,
pub trace: bool,
capture: bool,
pub captured_stdout: String,
/// Bindings in the entry (`# main` / sole object) env after it finishes.
pub entry_bindings: HashMap<String, Value>,
/// Silent branch/loop hits for `marqdo view` annotations.
pub view_trace: ViewTrace,
next_call_id: u32,
call_stack: Vec<u32>,
fn_ordinals: HashMap<String, u32>,
next_loop_id: u32,
/// Active loops: `(loop_id, iter_index_0based)`.
loop_stack: Vec<(u32, u32)>,
current_span: Span,
input: InputFeed,
host: HostContext,
debug: Option<Arc<DebugController>>,
/// Entry module pointer for `host_query("call_lib_path")` while plugins run.
site_module: Option<*const Module>,
}
struct Env {
vars: HashMap<String, Value>,
}
impl Env {
fn new() -> Self {
Self {
vars: HashMap::new(),
}
}
/// Phase 2: lift resolved Artifact Metadata into the entry environment.
/// Existing keys are left unchanged (`or_insert` semantics).
fn with_metadata(module: &Module) -> Self {
let mut env = Self::new();
for (k, v) in &module.metadata {
env.vars.entry(k.clone()).or_insert_with(|| v.clone());
}
env
}
fn get(&self, name: &str) -> Option<&Value> {
self.vars.get(name)
}
fn set(&mut self, name: String, value: Value) {
self.vars.insert(name, value);
}
fn vars_clone(&self) -> HashMap<String, Value> {
self.vars.clone()
}
}
pub(crate) enum EvArg {
Positional(Value),
Named(String, Value),
}
impl Interpreter {
pub fn new(path: Option<&Path>, trace: bool) -> Self {
Self {
path: path.map(|p| p.to_path_buf()),
trace,
capture: false,
captured_stdout: String::new(),
entry_bindings: HashMap::new(),
view_trace: ViewTrace::default(),
next_call_id: 1,
call_stack: Vec::new(),
fn_ordinals: HashMap::new(),
next_loop_id: 1,
loop_stack: Vec::new(),
current_span: Span::new(1, 1),
input: InputFeed::new(false, Vec::new()),
host: HostContext::for_run(path, Default::default(), Vec::new()),
debug: None,
site_module: None,
}
}
pub fn with_capture(path: Option<&Path>, trace: bool) -> Self {
Self {
path: path.map(|p| p.to_path_buf()),
trace,
capture: true,
captured_stdout: String::new(),
entry_bindings: HashMap::new(),
view_trace: ViewTrace::default(),
next_call_id: 1,
call_stack: Vec::new(),
fn_ordinals: HashMap::new(),
next_loop_id: 1,
loop_stack: Vec::new(),
current_span: Span::new(1, 1),
input: InputFeed::new(true, Vec::new()),
host: HostContext::for_capture(path, Default::default()),
debug: None,
site_module: None,
}
}
pub fn with_stdin(mut self, lines: Vec<String>) -> Self {
self.input = InputFeed::new(self.capture, lines);
self
}
pub fn with_host(mut self, host: HostContext) -> Self {
self.host = host;
self
}
pub fn with_debug(mut self, debug: Arc<DebugController>) -> Self {
self.debug = Some(debug);
self
}
pub fn take_plots(&mut self) -> Vec<crate::host::PlotArtifact> {
std::mem::take(&mut self.host.plots)
}
fn err(&self, message: impl Into<String>) -> anyhow::Error {
bail_at(self.path.as_deref(), self.current_span, message)
}
fn err_code(&self, code: &str, message: impl Into<String>) -> anyhow::Error {
anyhow::Error::new(
crate::diagnostics::Diagnostic::new(self.path.as_deref(), self.current_span, message)
.with_code(code),
)
}
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}");
use std::io::Write;
let _ = std::io::stdout().flush();
}
}
fn current_call_id(&self) -> u32 {
self.call_stack.last().copied().unwrap_or(0)
}
fn loop_ctx(&self) -> (Option<u32>, Option<u32>) {
self.loop_stack
.last()
.map(|(id, iter)| (Some(*id), Some(*iter)))
.unwrap_or((None, None))
}
fn push_view_call(&mut self, fun: &Function, env: &Env) {
if !self.capture {
return;
}
let call_id = self.next_call_id;
self.next_call_id += 1;
let ordinal = {
let e = self.fn_ordinals.entry(fun.name.clone()).or_insert(0);
*e += 1;
*e
};
let args_brief = fun
.params
.iter()
.filter_map(|p| {
env.get(&p.name)
.map(|v| format!("{}={}", p.name, brief_trace_val(v)))
})
.collect::<Vec<_>>()
.join(", ");
self.view_trace.calls.push(CallFrame {
call_id,
fn_name: fun.name.clone(),
fn_line: fun.span.line,
call_line: self.current_span.line,
ordinal,
args_brief,
});
self.call_stack.push(call_id);
}
fn pop_view_call(&mut self) {
if self.capture {
self.call_stack.pop();
}
}
fn begin_view_loop(
&mut self,
line: u32,
item: Option<&str>,
collection: Option<&str>,
) -> u32 {
let loop_id = self.next_loop_id;
self.next_loop_id += 1;
self.view_trace.loop_frames.push(LoopFrame {
loop_id,
line,
item_name: item.map(|s| s.to_string()),
collection: collection.map(|s| s.to_string()),
iterations: Vec::new(),
});
self.loop_stack.push((loop_id, 0));
loop_id
}
fn enter_loop_iter(&mut self, loop_id: u32, index: u32, item_value: &str) {
if let Some((_, cur)) = self.loop_stack.iter_mut().rev().find(|(id, _)| *id == loop_id)
{
*cur = index;
}
let call_id = self.current_call_id();
if let Some(fr) = self
.view_trace
.loop_frames
.iter_mut()
.find(|f| f.loop_id == loop_id)
{
fr.iterations.push(LoopIter {
index,
item_value: item_value.to_string(),
call_id,
});
}
}
fn end_view_loop(&mut self, loop_id: u32) {
if self
.loop_stack
.last()
.map(|(id, _)| *id == loop_id)
.unwrap_or(false)
{
self.loop_stack.pop();
}
}
fn record_stmt_event(&mut self, mut ev: StmtEvent) {
if self.capture {
if ev.loop_id.is_none() || ev.iter.is_none() {
let (lid, iter) = self.loop_ctx();
if ev.loop_id.is_none() {
ev.loop_id = lid;
}
if ev.iter.is_none() {
ev.iter = iter;
}
}
self.view_trace.events.push(ev);
}
}
fn record_branch_hit(&mut self, line: u32, arm_index: usize) {
let call_id = self.current_call_id();
if let Some(existing) = self.view_trace.branches.iter_mut().find(|h| {
h.line == line && h.arm_index == arm_index && h.call_id == call_id
}) {
existing.count += 1;
} else {
self.view_trace.branches.push(BranchHit {
line,
arm_index,
count: 1,
call_id,
});
}
let (loop_id, iter) = self.loop_ctx();
self.record_stmt_event(StmtEvent {
line,
kind: StmtEventKind::Branch,
name: None,
value_after: Some(format!("arm {}", arm_index + 1)),
arm_index: Some(arm_index),
iter,
call_id,
loop_id,
});
}
fn record_loop_hit(&mut self, line: u32, iterations: u32, last_item: Option<String>) {
if let Some(existing) = self.view_trace.loops.iter_mut().find(|h| h.line == line) {
existing.iterations = iterations;
if last_item.is_some() {
existing.last_item = last_item.clone();
}
} else {
self.view_trace.loops.push(LoopHit {
line,
iterations,
last_item: last_item.clone(),
});
}
let (loop_id, _) = self.loop_ctx();
self.record_stmt_event(StmtEvent {
line,
kind: StmtEventKind::Loop,
name: None,
value_after: Some(format!("{iterations} iters")),
arm_index: None,
// Summary event: total count (not 0-based index).
iter: Some(iterations),
call_id: self.current_call_id(),
loop_id,
});
}
/// Run a function by name anywhere in the module (for `lib/subtask` workers).
pub fn invoke_function(
&mut self,
module: &Module,
name: &str,
args: &[(String, Value)],
) -> Result<Value> {
let fun = find_function_anywhere(module, name)
.ok_or_else(|| self.err(format!("unknown function `{name}`")))?;
self.invoke_bound_function(module, fun, args)
}
/// Run an already-bound function node (SymbolId / source-line identity).
/// Prefer this over name lookup so nested same-named functions cannot drift (G07).
pub fn invoke_bound_function(
&mut self,
module: &Module,
fun: &Function,
args: &[(String, Value)],
) -> Result<Value> {
self.run_function(module, fun, Env::new(), args, false)
}
/// Bind named arguments for an external call. Unknown names, missing
/// required parameters, and contract mismatches are errors. Defaults run.
pub fn bind_external_args(
&mut self,
module: &Module,
fun: &Function,
args: &[(String, Value)],
) -> Result<Vec<(String, Value)>> {
self.current_span = fun.span;
self.host.current_line = fun.span.line;
let mut named: HashMap<String, Value> = HashMap::new();
for (k, v) in args {
if named.insert(k.clone(), v.clone()).is_some() {
return Err(self.err_code(
"call.duplicate_arg",
format!("duplicate named argument `{k}`"),
));
}
}
for k in named.keys() {
if !fun.params.iter().any(|p| &p.name == k) {
return Err(self.err_code(
"call.unknown_arg",
format!("unknown argument `{k}`"),
));
}
}
let ev: Vec<EvArg> = named
.into_iter()
.map(|(k, v)| EvArg::Named(k, v))
.collect();
let mut env = Env::new();
let bound = bind_function_args(self, module, fun, &mut env, &fun.params, &ev, false)
.map_err(|m| {
if m.starts_with("missing argument") {
self.err_code("call.missing_arg", m)
} else if m.starts_with("duplicate named argument") {
self.err_code("call.duplicate_arg", m)
} else {
self.err(m)
}
})?;
if let Some(c) = &fun.contract {
if let Some(d) = crate::contract::call_arg_diag(
c,
&fun.name,
&bound,
self.path.as_deref(),
fun.span,
) {
return Err(d.into());
}
}
let mut out = Vec::new();
for p in &fun.params {
if let Some(v) = bound.get(&p.name) {
out.push((p.name.clone(), v.clone()));
}
}
Ok(out)
}
/// Call a function using (and updating) [`Self::entry_bindings`] from `# main`.
/// Used by browser WASM sessions so handlers share state with the entry object.
pub fn invoke_in_entry(
&mut self,
module: &Module,
name: &str,
args: &[(String, Value)],
) -> Result<Value> {
let fun = find_function_anywhere(module, name)
.ok_or_else(|| self.err(format!("unknown function `{name}`")))?;
let mut env = Env::with_metadata(module);
for (k, v) in &self.entry_bindings {
env.set(k.clone(), v.clone());
}
let prev = self.site_module;
self.site_module = Some(module as *const Module);
let result = self.run_function(module, fun, env, args, true);
self.site_module = prev;
result
}
/// Evaluate only the entry object's top-level assignments, without running
/// calls/returns/control flow. This is the view plan's language-native
/// projection: cell tables are ordinary Marqdo values, not source scans.
/// Evaluate selected entry bindings plus their assignment dependencies.
/// This is the view plan's language-native projection: cell tables are
/// ordinary Marqdo values, not source scans.
pub fn capture_declarations(
&mut self,
module: &Module,
names: &[&str],
) -> Result<std::collections::HashMap<String, Value>> {
let prev = self.site_module;
self.site_module = Some(module as *const Module);
let result = (|| {
let entry = find_top(module, "main").or_else(|| {
let entries: Vec<&Function> = module
.functions
.iter()
.filter(|f| f.is_object() && f.params.is_empty())
.collect();
if entries.len() == 1 {
Some(entries[0])
} else {
None
}
});
let entry = entry.ok_or_else(|| self.err("no `# main` object to inspect"))?;
let assignments: std::collections::HashMap<&str, &Expr> = entry
.body
.iter()
.filter_map(|stmt| match stmt {
Stmt::Assign { name, value, .. } => Some((name.as_str(), value)),
_ => None,
})
.collect();
let mut env = Env::with_metadata(module);
let mut done = std::collections::HashSet::new();
let mut visiting = std::collections::HashSet::new();
fn resolve(
this: &mut Interpreter,
module: &Module,
fun: &Function,
assignments: &std::collections::HashMap<&str, &Expr>,
name: &str,
env: &mut Env,
done: &mut std::collections::HashSet<String>,
visiting: &mut std::collections::HashSet<String>,
) -> Result<()> {
if done.contains(name) {
return Ok(());
}
if !visiting.insert(name.to_string()) {
return Err(this.err(format!("cyclic view-plan binding `{name}`")));
}
let Some(expr) = assignments.get(name) else {
visiting.remove(name);
return Ok(());
};
let mut deps = std::collections::HashSet::new();
collect_decl_reads(expr, &mut deps);
for dep in deps {
if assignments.contains_key(dep.as_str()) && env.get(&dep).is_none() {
resolve(this, module, fun, assignments, &dep, env, done, visiting)?;
}
}
let value = this.eval_expr(module, fun, env, expr)?;
env.set(name.to_string(), value);
done.insert(name.to_string());
visiting.remove(name);
Ok(())
}
for name in names {
resolve(
self,
module,
entry,
&assignments,
name,
&mut env,
&mut done,
&mut visiting,
)?;
}
self.entry_bindings = env.vars_clone();
Ok(self.entry_bindings.clone())
})();
self.site_module = prev;
result
}
pub fn run_module(&mut self, module: &Module) -> Result<Value> {
let prev = self.site_module;
self.site_module = Some(module as *const Module);
let result = (|| {
if let Some(main) = find_top(module, "main") {
return self.run_function(module, main, Env::with_metadata(module), &[], true);
}
// Document-as-entry: sole top-level `#` object with no params (e.g. `# Hello World`).
let entries: Vec<&Function> = module
.functions
.iter()
.filter(|f| f.is_object() && f.params.is_empty())
.collect();
if entries.len() == 1 {
return self.run_function(
module,
entries[0],
Env::with_metadata(module),
&[],
true,
);
}
// Web Artifact entry (ADR 0007): `type: web|endpoint` may be pure document —
// no `# main`. Return a Result-shaped summary for run/check gold paths.
if let Some(kind) = crate::artifact::classify(&module.metadata) {
use crate::artifact::ArtifactKind;
if matches!(kind, ArtifactKind::Web | ArtifactKind::Endpoint) {
return Ok(Self::artifact_run_summary(module, kind));
}
}
bail!("no `# main` object to run");
})();
self.site_module = prev;
result
}
fn artifact_run_summary(module: &Module, kind: crate::artifact::ArtifactKind) -> Value {
use crate::artifact::{endpoint_path, http_method, web_route, ArtifactKind};
let kind_s = match kind {
ArtifactKind::Web => "web",
ArtifactKind::Endpoint => "endpoint",
ArtifactKind::Prompt => "prompt",
ArtifactKind::Other => "other",
};
let mut value = vec![
("kind".into(), Value::Text(kind_s.into())),
("method".into(), Value::Text(http_method(&module.metadata))),
];
match kind {
ArtifactKind::Web => {
if let Some(r) = web_route(&module.metadata) {
value.push(("route".into(), Value::Text(r)));
}
}
ArtifactKind::Endpoint => {
if let Some(r) = endpoint_path(&module.metadata) {
value.push(("path".into(), Value::Text(r)));
}
}
_ => {}
}
Value::Map(vec![
("ok".into(), Value::Bool(true)),
("value".into(), Value::Map(value)),
("error".into(), Value::None),
])
}
/// Pin `module` as site and call `lib.member` (isolated worker / CLI `--call-lib-path`).
pub fn run_site_lib_path(
&mut self,
module: &Module,
path: &str,
args: Option<&Value>,
) -> std::result::Result<Value, String> {
let prev = self.site_module;
self.site_module = Some(module as *const Module);
let out = self.call_site_lib_path(path, args);
self.site_module = prev;
out
}
/// Resolve `lib.member` on the site (entry) module — used by ABI `call_lib_path`.
pub(crate) fn call_site_lib_path(
&mut self,
path: &str,
args: Option<&Value>,
) -> std::result::Result<Value, String> {
let site = self
.site_module
.ok_or_else(|| "call_lib_path: no site module".to_string())?;
let site = unsafe { &*site };
let parts: Vec<String> = path
.split('.')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if parts.len() < 2 {
return Err(format!(
"call_lib_path: need `lib.member`, got `{path}`"
));
}
let mut ev_args: Vec<EvArg> = Vec::new();
if let Some(Value::Map(pairs)) = args {
for (k, v) in pairs {
ev_args.push(EvArg::Named(k.clone(), v.clone()));
}
}
self.eval_path_call(site, &parts, &ev_args)
.map_err(|e| e.to_string())
}
fn call_plugin_registered(
&mut self,
name: &str,
bound: &HashMap<String, Value>,
) -> std::result::Result<Value, String> {
struct HookData {
interp: *mut Interpreter,
}
fn trampoline(
data: *mut (),
path: &str,
args: Option<&Value>,
) -> std::result::Result<Value, String> {
let data = unsafe { &mut *(data as *mut HookData) };
let interp = unsafe { &mut *data.interp };
interp.call_site_lib_path(path, args)
}
let mut data = HookData {
interp: self as *mut Interpreter,
};
let hook = crate::host::plugin::LibPathCall {
call: trampoline,
data: &mut data as *mut HookData as *mut (),
};
crate::host::plugin::with_lib_path_call(hook, || {
crate::host::plugin::call_registered(&mut self.host, name, bound)
})
}
fn run_function(
&mut self,
module: &Module,
fun: &Function,
mut env: Env,
args: &[(String, Value)],
capture_entry_env: bool,
) -> Result<Value> {
if self.trace {
emit_trace(
self.path.as_deref(),
Some(fun.span),
"enter_fn",
&[("fn", fun.name.as_str())],
);
}
for (k, v) in args {
env.set(k.clone(), v.clone());
}
for p in &fun.params {
if env.get(&p.name).is_none() {
env.set(p.name.clone(), Value::None);
}
}
let ret = Value::None;
self.push_view_call(fun, &env);
self.host.push_call_frame(&fun.name);
let body_result = (|| -> Result<Value> {
for stmt in &fun.body {
if let Some(v) = self.exec_stmt(module, fun, &mut env, stmt)? {
return Ok(v);
}
}
Ok(ret)
})();
self.host.pop_call_frame();
self.pop_view_call();
let ret = body_result?;
if capture_entry_env {
self.entry_bindings = env.vars_clone();
}
if self.trace {
let display = ret.as_display();
emit_trace(
self.path.as_deref(),
Some(fun.span),
"leave_fn",
&[("fn", fun.name.as_str()), ("value", display.as_str())],
);
}
Ok(ret)
}
fn exec_stmt(
&mut self,
module: &Module,
fun: &Function,
env: &mut Env,
stmt: &Stmt,
) -> Result<Option<Value>> {
let span = stmt_span(stmt);
self.current_span = span;
self.host.current_line = span.line;
if let Some(dbg) = &self.debug {
dbg.on_stmt(span.line, &fun.name, &env.vars, &self.captured_stdout)
.map_err(|m| self.err(m))?;
}
match stmt {
Stmt::Assign { name, value, span, .. } => {
self.current_span = *span;
let v = self.eval_expr(module, fun, env, value)?;
// 契约边界 3(T2.2):表绑定 vs 字段契约。
if let Some(c) = fun.var_contracts.get(name) {
if let Some(d) =
crate::contract::fields_diag(c, name, &v, self.path.as_deref(), *span)
{
return Err(d.into());
}
}
if self.trace {
let display = v.as_display();
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[
("kind", "assign"),
("name", name.as_str()),
("value", display.as_str()),
],
);
}
if self.capture {
self.record_stmt_event(StmtEvent {
line: span.line,
kind: StmtEventKind::Assign,
name: Some(name.clone()),
value_after: Some(v.as_display()),
arm_index: None,
iter: None,
call_id: self.current_call_id(),
loop_id: None,
});
}
env.set(name.clone(), v);
Ok(None)
}
Stmt::Return { value, span } => {
self.current_span = *span;
let v = self.eval_expr(module, fun, env, value)?;
// 契约边界 2(T2.2):返回值 vs 返回契约。
if let Some(c) = &fun.contract {
if let Some(d) =
crate::contract::return_diag(c, &fun.name, &v, self.path.as_deref(), *span)
{
return Err(d.into());
}
}
if self.trace {
let display = v.as_display();
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[("kind", "return"), ("value", display.as_str())],
);
}
if self.capture {
self.record_stmt_event(StmtEvent {
line: span.line,
kind: StmtEventKind::Return,
name: None,
value_after: Some(v.as_display()),
arm_index: None,
iter: None,
call_id: self.current_call_id(),
loop_id: None,
});
}
Ok(Some(v))
}
Stmt::Call { call, span } => {
self.current_span = *span;
if self.trace {
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[("kind", "call"), ("callee", call.callee.as_str())],
);
}
let stdout_before = self.captured_stdout.len();
let v = self.eval_call(module, fun, env, call)?;
if self.capture {
let (loop_id, iter) = self.loop_ctx();
self.record_stmt_event(StmtEvent {
line: span.line,
kind: StmtEventKind::Call,
name: Some(call.callee.clone()),
value_after: Some(call_event_brief(
&v,
&self.captured_stdout,
stdout_before,
&call.callee,
)),
arm_index: None,
iter,
call_id: self.current_call_id(),
loop_id,
});
}
Ok(None)
}
Stmt::Expr { value, span } => {
self.current_span = *span;
if self.trace {
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[("kind", "expr")],
);
}
let stdout_before = self.captured_stdout.len();
let v = self.eval_expr(module, fun, env, value)?;
if self.capture {
let (loop_id, iter) = self.loop_ctx();
let name = match value {
Expr::Call(c) => Some(c.callee.clone()),
_ => None,
};
self.record_stmt_event(StmtEvent {
line: span.line,
kind: StmtEventKind::Call,
name: name.clone(),
value_after: Some(call_event_brief(
&v,
&self.captured_stdout,
stdout_before,
name.as_deref().unwrap_or("expr"),
)),
arm_index: None,
iter,
call_id: self.current_call_id(),
loop_id,
});
}
Ok(None)
}
Stmt::Branch { arms, span } => {
self.current_span = *span;
if self.trace {
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[("kind", "branch")],
);
}
for (arm_index, arm) in arms.iter().enumerate() {
let take = match &arm.condition {
None => true,
Some(cond) => self.eval_expr(module, fun, env, cond)?.truthy(),
};
if take {
if self.capture {
self.record_branch_hit(span.line, arm_index);
}
for s in &arm.body {
if let Some(v) = self.exec_stmt(module, fun, env, s)? {
return Ok(Some(v));
}
}
break;
}
}
Ok(None)
}
Stmt::While {
condition,
body,
span,
} => {
self.current_span = *span;
if self.trace {
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[("kind", "while")],
);
}
let loop_id = if self.capture {
Some(self.begin_view_loop(span.line, None, None))
} else {
None
};
let mut guard = 0u32;
while self.eval_expr(module, fun, env, condition)?.truthy() {
guard += 1;
if guard > 1_000_000 {
return Err(self.err("while loop exceeded iteration limit"));
}
if let Some(lid) = loop_id {
self.enter_loop_iter(lid, guard - 1, &format!("iter {guard}"));
}
for s in body {
if let Some(v) = self.exec_stmt(module, fun, env, s)? {
if self.capture {
if let Some(lid) = loop_id {
self.end_view_loop(lid);
}
self.record_loop_hit(span.line, guard, None);
}
return Ok(Some(v));
}
}
}
if self.capture {
if let Some(lid) = loop_id {
self.end_view_loop(lid);
}
self.record_loop_hit(span.line, guard, None);
}
Ok(None)
}
Stmt::ForEach {
item,
collection,
label: _,
body,
span,
} => {
self.current_span = *span;
if self.trace {
emit_trace(
self.path.as_deref(),
Some(*span),
"stmt",
&[
("kind", "foreach"),
("item", item.as_str()),
("collection", collection.as_str()),
],
);
}
let coll = env.get(collection).cloned().ok_or_else(|| {
self.err(format!("undefined collection `{collection}`"))
})?;
let items = match builtin_iter_items(&coll) {
Ok(Value::List(xs)) => xs,
Ok(_) => unreachable!(),
Err(m) => return Err(self.err(m)),
};
let loop_id = if self.capture {
Some(self.begin_view_loop(
span.line,
Some(item.as_str()),
Some(collection.as_str()),
))
} else {
None
};
let mut iterations = 0u32;
let mut last_item: Option<String> = None;
for val in items {
let index = iterations;
iterations += 1;
let display = val.as_display();
last_item = Some(display.clone());
if let Some(lid) = loop_id {
self.enter_loop_iter(lid, index, &display);
self.record_stmt_event(StmtEvent {
line: span.line,
kind: StmtEventKind::BindRef,
name: Some(item.clone()),
value_after: Some(format!(
"{collection}[{index}]={display}"
)),
arm_index: None,
iter: Some(index),
call_id: self.current_call_id(),
loop_id: Some(lid),
});
}
env.set(item.clone(), val);
for s in body {
if let Some(v) = self.exec_stmt(module, fun, env, s)? {
if self.capture {
if let Some(lid) = loop_id {
self.end_view_loop(lid);
}
self.record_loop_hit(span.line, iterations, last_item.clone());
}
return Ok(Some(v));
}
}
}
if self.capture {
if let Some(lid) = loop_id {
self.end_view_loop(lid);
}
self.record_loop_hit(span.line, iterations, last_item);
}
Ok(None)
}
}
}
fn resolve_index_key(
&mut self,
_module: &Module,
_fun: &Function,
env: &mut Env,
label: &IndexKey,
) -> Result<String> {
match label {
IndexKey::Lit(s) => Ok(s.clone()),
IndexKey::Var(name) => {
let v = env.get(name).cloned().ok_or_else(|| {
self.err(format!("undefined variable `{name}` in footnote key"))
})?;
Ok(v.as_display())
}
}
}
fn eval_expr(
&mut self,
module: &Module,
fun: &Function,
env: &mut Env,
expr: &Expr,
) -> Result<Value> {
match expr {
Expr::Literal(lit) => Ok(lit_to_value(lit)),
Expr::Var(name) => env
.get(name)
.cloned()
.ok_or_else(|| self.err(format!("undefined variable `{name}`"))),
Expr::Interp(parts) => {
let mut s = String::new();
for part in parts {
match part {
InterpPart::Lit(t) => s.push_str(t),
InterpPart::Var(n) => {
let v = env
.get(n)
.ok_or_else(|| self.err(format!("undefined variable `{n}`")))?;
s.push_str(&v.as_display());
}
InterpPart::Index { base, labels } => {
let mut v = env.get(base).cloned().ok_or_else(|| {
self.err(format!("undefined variable `{base}`"))
})?;
for label in labels {
v = builtin_footnote_get(&v, label).map_err(|m| self.err(m))?;
}
s.push_str(&v.as_display());
}
}
}
Ok(Value::Text(s))
}
Expr::Unary { op, expr } => {
let v = self.eval_expr(module, fun, env, expr)?;
match op {
UnaryOp::Not => Ok(Value::Bool(!v.truthy())),
UnaryOp::Neg => match v {
Value::Int(n) => Ok(Value::Int(-n)),
Value::Num(n) => Ok(Value::Num(-n)),
_ => Err(self.err("unary `-` needs int or num")),
},
}
}
Expr::Binary { op, left, right } => {
let l = self.eval_expr(module, fun, env, left)?;
match op {
BinaryOp::And => {
if !l.truthy() {
return Ok(Value::Bool(false));
}
let r = self.eval_expr(module, fun, env, right)?;
return Ok(Value::Bool(r.truthy()));
}
BinaryOp::Or => {
if l.truthy() {
return Ok(Value::Bool(true));
}
let r = self.eval_expr(module, fun, env, right)?;
return Ok(Value::Bool(r.truthy()));
}
_ => {}
}
let r = self.eval_expr(module, fun, env, right)?;
if let Some(v) = crate::linalg_ops::try_matrix_binary(
&mut self.host,
*op,
&l,
&r,
)
.map_err(|e| self.err(e))?
{
return Ok(v);
}
eval_binary(*op, &l, &r).map_err(|e| self.err(e.to_string()))
}
Expr::Call(call) => self.eval_call(module, fun, env, call),
Expr::List(items) => {
let mut out = Vec::new();
for it in items {
out.push(self.eval_expr(module, fun, env, it)?);
}
Ok(Value::List(out))
}
Expr::Map(pairs) => {
let mut out = Vec::new();
for (k, e) in pairs {
out.push((k.clone(), self.eval_expr(module, fun, env, e)?));
}
Ok(Value::Map(out))
}
Expr::Index { base, label } => {
let v = self.eval_expr(module, fun, env, base)?;
let key = self.resolve_index_key(module, fun, env, label)?;
// 契约边界 4(T2.2):字段访问 vs 字段契约——键存在性**先于**取值
// (契约诊断优先于运行时 `missing map key`)。
if let Expr::Var(name) = base.as_ref() {
if let Some(c) = fun.var_contracts.get(name) {
if let Some(d) = crate::contract::index_diag(
c,
name,
&key,
&Value::None,
self.path.as_deref(),
self.current_span,
) {
return Err(d.into());
}
}
}
let out = builtin_footnote_get(&v, &key).map_err(|m| self.err(m))?;
if let Expr::Var(name) = base.as_ref() {
if let Some(c) = fun.var_contracts.get(name) {
if let Some(d) = crate::contract::index_diag(
c,
name,
&key,
&out,
self.path.as_deref(),
self.current_span,
) {
return Err(d.into());
}
}
}
Ok(out)
}
Expr::Formula(e) => Ok(Value::Formula(e.clone())),
Expr::Code(c) => Ok(Value::Code(c.clone())),
// `<TAB>` M2: the label is inert prose; only the payload evaluates.
Expr::Occluded { payload, .. } => match payload {
Some(inner) => self.eval_expr(module, fun, env, inner),
None => Ok(Value::None),
},
}
}
fn eval_call(
&mut self,
module: &Module,
fun: &Function,
env: &mut Env,
call: &CallExpr,
) -> Result<Value> {
let mut call = call.clone();
// Method callees keep author names (`绘图` on quantum ≠ math `host_plot`).
if call.path.is_none() && call.receiver.is_none() {
let callee = crate::aliases::normalize_call_callee_and_args(
&call.callee,
&mut call.args,
);
call.callee = callee;
}
for m in &call.pre_modifiers {
if call.args.iter().any(|a| matches!(a, Arg::Named { name, .. } if name == m)) {
return Err(self.err(format!(
"pre-bracket modifier `{m}` conflicts with named argument `{m}`"
)));
}
}
let mut ev_args = Vec::new();
for m in &call.pre_modifiers {
ev_args.push(EvArg::Named(m.clone(), Value::Bool(true)));
}
for arg in &call.args {
match arg {
Arg::Positional(e) => {
ev_args.push(EvArg::Positional(self.eval_expr(module, fun, env, e)?));
}
Arg::Named { name, value } => {
ev_args.push(EvArg::Named(
name.clone(),
self.eval_expr(module, fun, env, value)?,
));
}
}
}
if let Some(recv_name) = &call.receiver {
return self.eval_method_call(module, fun, env, recv_name, &call.callee, &ev_args);
}
// Local-var method sugar (`a.b` when `a` is in env) before BoundCall path resolve.
if let Some(path) = &call.path {
if path.len() == 2
&& env.get(&path[0]).is_some()
&& !module.import_modules.contains_key(&path[0])
{
let recv = path[0].clone();
let method = path[1].clone();
return self.eval_method_call(module, fun, env, &recv, &method, &ev_args);
}
}
use crate::sema::bind::{resolve_for_exec, DynamicReason, ExecTarget};
match resolve_for_exec(module, fun, &call) {
ExecTarget::Local(target) => {
self.eval_bound_function_call(module, fun, env, target, &ev_args)
}
ExecTarget::Import {
lib: lib_mod,
fun: target,
..
} => self.eval_bound_function_call(lib_mod, fun, env, target, &ev_args),
ExecTarget::Builtin(name) => self.eval_builtin_call(name, &ev_args),
ExecTarget::Host(hf) => {
let mut params: Vec<String> =
hf.required_params().iter().map(|s| (*s).to_string()).collect();
for p in hf.optional_params() {
params.push((*p).to_string());
}
let bound = bind_args(&params, &ev_args, true).map_err(|m| self.err(m))?;
for req in hf.required_params() {
if !bound.contains_key(*req) {
return Err(self.err(format!("{} requires `{req}`", hf.name())));
}
}
call_host(&mut self.host, hf, &bound).map_err(|m| self.err(m))
}
ExecTarget::Dynamic {
reason: DynamicReason::CallFn,
..
} => {
let bound = bind_args(&["name".into()], &ev_args, false)
.map_err(|m| self.err(m))?;
let name = match bound.get("name") {
Some(Value::Text(s)) => s.as_str(),
_ => return Err(self.err("call_fn requires text name")),
};
let target = lookup_function(module, fun, name).ok_or_else(|| {
self.err(format!("call_fn: unknown function `{name}`"))
})?;
if !target.params.is_empty() {
return Err(self.err(format!(
"call_fn: `{name}` must have no parameters"
)));
}
self.run_function(module, target, Env::new(), &[], false)
}
ExecTarget::Dynamic {
reason: DynamicReason::Plugin,
name,
} => {
if let Some(reg) = self.host.plugins.get(&name).cloned() {
let bound =
bind_args(&reg.params, &ev_args, false).map_err(|m| self.err(m))?;
return self
.call_plugin_registered(&name, &bound)
.map_err(|m| self.err(m));
}
Err(self.err(format!("unknown function `{name}`")))
}
ExecTarget::Dynamic {
reason: DynamicReason::MethodReceiver,
name,
} => {
if let Some(path) = &call.path {
if path.len() == 2 && env.get(&path[0]).is_some() {
return self.eval_method_call(
module,
fun,
env,
&path[0],
&path[1],
&ev_args,
);
}
}
Err(self.err(format!("unresolved dynamic call `{name}`")))
}
ExecTarget::Unresolved { message, .. } => Err(self.err(message)),
}
}
/// Invoke a function already resolved via [`crate::sema::bind::resolve_for_exec`].
fn eval_bound_function_call(
&mut self,
module: &Module,
caller: &Function,
env: &mut Env,
target: &Function,
ev_args: &[EvArg],
) -> Result<Value> {
let bound =
bind_function_args(self, module, caller, env, &target.params, ev_args, false)
.map_err(|m| self.err(m))?;
if let Some(c) = &target.contract {
if let Some(d) = crate::contract::call_arg_diag(
c,
&target.name,
&bound,
self.path.as_deref(),
self.current_span,
) {
return Err(d.into());
}
}
let mut call_env = Env::new();
for (k, v) in bound {
call_env.set(k, v);
}
self.host.push_call_site_line(self.host.current_line);
let result = self.run_function(module, target, call_env, &[], false);
self.host.pop_call_site_line();
let result = result?;
if target.is_object() {
Ok(tag_instance(&target.name, result))
} else {
Ok(result)
}
}
fn eval_builtin_call(&mut self, name: &str, ev_args: &[EvArg]) -> Result<Value> {
match name {
"print" => {
let bound = bind_args(&["text".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let text = bound
.get("text")
.map(|v| v.as_display())
.ok_or_else(|| self.err("print requires text (named or positional)"))?;
self.emit_line(&text);
Ok(Value::None)
}
"input" => {
let bound = bind_args(&["prompt".into()], ev_args, true)
.map_err(|m| self.err(m))?;
let prompt = bound
.get("prompt")
.map(|v| v.as_display())
.unwrap_or_default();
let line = if self.capture {
self.emit_prompt(&prompt);
self.input.read_line()
} else if crate::input_feed::stdin_is_tty() {
self.input
.read_line_with_prompt(&prompt)
.map(|(line, _)| line)
} else {
self.emit_prompt(&prompt);
self.input.read_line()
}
.map_err(|e| {
let msg = e.to_string();
if msg.contains("input needs a line") {
self.err(msg)
} else {
e
}
})?;
Ok(Value::Text(line))
}
"len" => {
let bound = bind_args(&["value".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let v = bound
.get("value")
.ok_or_else(|| self.err("len requires value"))?;
let n = builtin_len(v).map_err(|m| self.err(m))?;
Ok(Value::Int(n))
}
"str" => {
let bound = bind_args(&["value".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let v = bound
.get("value")
.ok_or_else(|| self.err("str requires value"))?;
Ok(builtin_str(v))
}
"int" => {
let bound = bind_args(&["value".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let v = bound
.get("value")
.ok_or_else(|| self.err("int requires value"))?;
let n = builtin_int(v).map_err(|m| self.err(m))?;
Ok(Value::Int(n))
}
"type" => {
let bound = bind_args(&["value".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let v = bound
.get("value")
.ok_or_else(|| self.err("type requires value"))?;
Ok(builtin_type(v))
}
"trim" => {
let bound = bind_args(&["value".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let v = bound
.get("value")
.ok_or_else(|| self.err("trim requires value"))?;
builtin_trim(v).map_err(|m| self.err(m))
}
"split" => {
let bound = bind_args(&["value".into(), "sep".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let value = bound
.get("value")
.ok_or_else(|| self.err("split requires value"))?;
let sep = bound
.get("sep")
.ok_or_else(|| self.err("split requires sep"))?;
builtin_split(value, sep).map_err(|m| self.err(m))
}
"join" => {
let bound = bind_args(&["value".into(), "sep".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let value = bound
.get("value")
.ok_or_else(|| self.err("join requires value"))?;
let sep = bound
.get("sep")
.ok_or_else(|| self.err("join requires sep"))?;
builtin_join(value, sep).map_err(|m| self.err(m))
}
"at" => {
let bound = bind_args(&["value".into(), "index".into()], ev_args, false)
.map_err(|m| self.err(m))?;
let value = bound
.get("value")
.ok_or_else(|| self.err("at requires value"))?;
let index = bound
.get("index")
.ok_or_else(|| self.err("at requires index"))?;
builtin_at(value, index).map_err(|m| self.err(m))
}
other => Err(self.err(format!("unknown builtin `{other}`"))),
}
}
/// Resolve bare path `lib.member` / `lib.Type.member` (definition-tree addressing).
pub(crate) fn eval_path_call(
&mut self,
module: &Module,
path: &[String],
ev_args: &[EvArg],
) -> Result<Value> {
let (lib, node) = locate_import_function(module, path).map_err(|m| self.err(m))?;
let display = path.join(".");
let bound = {
let mut dummy_env = Env::new();
bind_function_args(
self,
lib,
node,
&mut dummy_env,
&node.params,
ev_args,
false,
)
.map_err(|m| self.err(m))?
};
// 契约边界 1(T2.2):库路径调用的实参 vs 形参契约。
if let Some(c) = &node.contract {
if let Some(d) = crate::contract::call_arg_diag(
c,
&display,
&bound,
self.path.as_deref(),
self.current_span,
) {
return Err(d.into());
}
}
let mut call_env = Env::new();
for (k, v) in bound {
call_env.set(k, v);
}
self.host.push_call_site_line(self.host.current_line);
let result = self.run_function(lib, node, call_env, &[], false);
self.host.pop_call_site_line();
let result = result?;
if node.is_object() {
Ok(tag_instance(&node.name, result))
} else {
Ok(result)
}
}
fn eval_method_call(
&mut self,
module: &Module,
fun: &Function,
env: &mut Env,
recv_name: &str,
method: &str,
ev_args: &[EvArg],
) -> Result<Value> {
let recv = env
.get(recv_name)
.cloned()
.ok_or_else(|| self.err(format!("undefined variable `{recv_name}`")))?;
let type_name = instance_type_name(&recv).map_err(|m| self.err(m))?;
if find_object_type(module, &type_name).is_none() {
return Err(self.err(format!("unknown object type `{type_name}`")));
}
let (owner, _obj, target) = find_method_along_bases(module, &type_name, method)
.ok_or_else(|| {
let chain = crate::inherit::inheritance_chain(module, &type_name)
.into_iter()
.map(|o| o.name.as_str())
.collect::<Vec<_>>()
.join(" → ");
self.err(format!(
"unknown method `{type_name}.{method}` (searched {chain})"
))
})?;
let bound = bind_function_args(self, module, fun, env, &target.params, ev_args, false)
.map_err(|m| self.err(m))?;
// 契约边界 1(T2.2):方法调用的实参 vs 形参契约。
if let Some(c) = &target.contract {
if let Some(d) = crate::contract::call_arg_diag(
c,
&target.name,
&bound,
self.path.as_deref(),
self.current_span,
) {
return Err(d.into());
}
}
let mut call_env = Env::new();
for (k, v) in bound {
call_env.set(k, v);
}
call_env.set("自".into(), recv.clone());
call_env.set("self".into(), recv.clone());
self.host.push_call_site_line(self.host.current_line);
let result = self.run_function(owner, target, call_env, &[], false);
self.host.pop_call_site_line();
let result = result?;
if crate::linalg_ops::is_matrix_value(&recv) {
Ok(crate::linalg_ops::retag_matrix_like(&type_name, result))
} else {
Ok(result)
}
}
}
fn instance_type_name(v: &Value) -> std::result::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(type_name: &str, value: Value) -> Value {
match value {
Value::Map(mut entries) => {
// Always stamp the constructed type so explicit `` `self` = > Parent ``
// in 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),
]),
}
}
/// `lib.member` / `lib.Type.member` against frontmatter imports. Does not execute.
pub(crate) fn locate_import_function<'a>(
module: &'a Module,
path: &[String],
) -> Result<(&'a Module, &'a Function), String> {
let display = path.join(".");
if path.len() < 2 {
return Err(format!(
"library path `{display}`: need at least `lib.member`"
));
}
let lib = module
.import_modules
.get(&path[0])
.ok_or_else(|| format!("unknown library `{}` (import it in frontmatter)", path[0]))?;
let mut parent_is_object = false;
let mut node = lib
.functions
.iter()
.find(|f| f.name == path[1])
.ok_or_else(|| format!("unknown `{display}`"))?;
for seg in &path[2..] {
parent_is_object = node.is_object();
node = node
.children
.iter()
.find(|c| c.name == *seg)
.ok_or_else(|| format!("unknown `{display}`"))?;
}
if parent_is_object && !node.is_object() && crate::ast::function_uses_receiver(node) {
return Err(format!(
"`{display}` is an instance method; call it as `var`.{}",
node.name
));
}
Ok((lib, node))
}
/// Bind evaluated args onto parameter names. Err is a plain message (caller adds span/path).
fn bind_function_args(
interp: &mut Interpreter,
module: &Module,
caller: &Function,
caller_env: &mut Env,
params: &[Param],
args: &[EvArg],
allow_missing: bool,
) -> std::result::Result<HashMap<String, Value>, String> {
let mut named: HashMap<String, Value> = HashMap::new();
let mut positionals = Vec::new();
for a in args {
match a {
EvArg::Positional(v) => positionals.push(v.clone()),
EvArg::Named(k, v) => {
if named.contains_key(k) {
return Err(format!("duplicate named argument `{k}`"));
}
named.insert(k.clone(), v.clone());
}
}
}
let mut out: HashMap<String, Value> = HashMap::new();
let mut used_named = HashSet::new();
let mut pos_i = 0usize;
for p in params {
if let Some(v) = named.get(&p.name) {
out.insert(p.name.clone(), v.clone());
used_named.insert(p.name.clone());
} else if pos_i < positionals.len() {
out.insert(p.name.clone(), positionals[pos_i].clone());
pos_i += 1;
} else if let Some(def) = &p.default {
let v = interp
.eval_expr(module, caller, caller_env, def)
.map_err(|e| e.to_string())?;
out.insert(p.name.clone(), v);
} else if !allow_missing {
return Err(format!("missing argument for parameter `{}`", p.name));
}
}
if pos_i < positionals.len() {
return Err(format!(
"too many positional arguments ({} extra)",
positionals.len() - pos_i
));
}
for (k, v) in named {
if !used_named.contains(&k) && !out.contains_key(&k) {
out.insert(k, v);
}
}
Ok(out)
}
/// Bind evaluated args onto parameter names (host / plugin functions).
fn bind_args(
params: &[String],
args: &[EvArg],
allow_missing: bool,
) -> std::result::Result<HashMap<String, Value>, String> {
let mut named: HashMap<String, Value> = HashMap::new();
let mut positionals = Vec::new();
for a in args {
match a {
EvArg::Positional(v) => positionals.push(v.clone()),
EvArg::Named(k, v) => {
if named.contains_key(k) {
return Err(format!("duplicate named argument `{k}`"));
}
named.insert(k.clone(), v.clone());
}
}
}
let mut out: HashMap<String, Value> = HashMap::new();
let mut used_named = HashSet::new();
let mut pos_i = 0usize;
for p in params {
if let Some(v) = named.get(p) {
out.insert(p.clone(), v.clone());
used_named.insert(p.clone());
} else if pos_i < positionals.len() {
out.insert(p.clone(), positionals[pos_i].clone());
pos_i += 1;
} else if !allow_missing {
return Err(format!("missing argument for parameter `{p}`"));
}
}
if pos_i < positionals.len() {
return Err(format!(
"too many positional arguments ({} extra)",
positionals.len() - pos_i
));
}
for (k, v) in named {
if !used_named.contains(&k) && !out.contains_key(&k) {
out.insert(k, v);
}
}
Ok(out)
}
fn collect_decl_reads(expr: &Expr, out: &mut std::collections::HashSet<String>) {
match expr {
Expr::Occluded { payload, .. } => {
if let Some(inner) = payload {
collect_decl_reads(inner, out);
}
}
Expr::Var(name) => {
out.insert(name.clone());
}
Expr::Interp(parts) => {
for part in parts {
match part {
InterpPart::Var(name) => {
out.insert(name.clone());
}
InterpPart::Index { base, .. } => {
out.insert(base.clone());
}
InterpPart::Lit(_) => {}
}
}
}
Expr::Index { base, label } => {
collect_decl_reads(base, out);
if let IndexKey::Var(name) = label {
out.insert(name.clone());
}
}
Expr::Binary { left, right, .. } => {
collect_decl_reads(left, out);
collect_decl_reads(right, out);
}
Expr::Unary { expr, .. } => collect_decl_reads(expr, out),
Expr::List(xs) => {
for x in xs {
collect_decl_reads(x, out);
}
}
Expr::Map(entries) => {
for (_, v) in entries {
collect_decl_reads(v, out);
}
}
Expr::Call(call) => {
if let Some(receiver) = &call.receiver {
out.insert(receiver.clone());
}
for arg in &call.args {
match arg {
Arg::Positional(e) | Arg::Named { value: e, .. } => {
collect_decl_reads(e, out);
}
}
}
}
Expr::Literal(_) | Expr::Formula(_) | Expr::Code(_) => {}
}
}
fn find_top<'a>(module: &'a Module, name: &str) -> Option<&'a Function> {
module.functions.iter().find(|f| f.name == name)
}
/// Resolve `#` object type by name in the entry module or any imported library.
fn find_object_type<'a>(module: &'a Module, name: &str) -> Option<(&'a Module, &'a Function)> {
fn search<'a>(
module: &'a Module,
name: &str,
seen: &mut std::collections::HashSet<*const Module>,
) -> Option<(&'a Module, &'a Function)> {
let key = module as *const Module;
if !seen.insert(key) {
return None;
}
if let Some(f) = module
.functions
.iter()
.find(|f| f.name == name && f.is_object())
{
return Some((module, f));
}
for lib in module.import_modules.values() {
if let Some(hit) = search(lib, name, seen) {
return Some(hit);
}
}
None
}
let mut seen = std::collections::HashSet::new();
search(module, name, &mut seen)
}
/// Resolve `` `obj`.method `` along the inheritance chain (`_type` first, then bases).
fn find_method_along_bases<'a>(
module: &'a Module,
type_name: &str,
method: &str,
) -> Option<(&'a Module, &'a Function, &'a Function)> {
let mut cur = type_name.to_string();
let mut seen = std::collections::HashSet::new();
while seen.insert(cur.clone()) {
let (owner, obj) = find_object_type(module, &cur)?;
if let Some(target) = obj.children.iter().find(|c| c.name == method) {
return Some((owner, obj, target));
}
match &obj.base {
Some(b) => cur = b.clone(),
None => break,
}
}
None
}
fn find_function_anywhere<'a>(module: &'a Module, name: &str) -> Option<&'a Function> {
for f in &module.functions {
if f.name == name {
return Some(f);
}
if let Some(child) = find_in_tree(f, name) {
return Some(child);
}
}
None
}
fn lookup_function<'a>(
module: &'a Module,
current: &'a Function,
name: &str,
) -> Option<&'a Function> {
if let Some(f) = find_in_tree(current, name) {
return Some(f);
}
module.functions.iter().find(|f| f.name == name)
}
fn find_in_tree<'a>(fun: &'a Function, name: &str) -> Option<&'a Function> {
for child in &fun.children {
if child.name == name {
return Some(child);
}
if let Some(f) = find_in_tree(child, name) {
return Some(f);
}
}
None
}
fn lit_to_value(lit: &Literal) -> Value {
match lit {
Literal::None => Value::None,
Literal::Bool(b) => Value::Bool(*b),
Literal::Int(n) => Value::Int(*n),
Literal::Num(n) => Value::Num(*n),
Literal::Text(s) => Value::Text(s.clone()),
}
}
fn eval_binary(op: BinaryOp, l: &Value, r: &Value) -> Result<Value> {
match op {
BinaryOp::Add => match (l, r) {
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a + b)),
(Value::Num(a), Value::Num(b)) => Ok(Value::Num(a + b)),
(Value::Int(a), Value::Num(b)) => Ok(Value::Num(*a as f64 + b)),
(Value::Num(a), Value::Int(b)) => Ok(Value::Num(a + *b as f64)),
(Value::Text(a), Value::Text(b)) => Ok(Value::Text(format!("{a}{b}"))),
(Value::Text(a), Value::Secret(b)) => Ok(Value::Text(format!("{a}{b}"))),
(Value::Secret(a), Value::Text(b)) => Ok(Value::Text(format!("{a}{b}"))),
(Value::Secret(a), Value::Secret(b)) => Ok(Value::Text(format!("{a}{b}"))),
(Value::Text(a), b) => Ok(Value::Text(format!("{a}{}", b.as_display()))),
(a, Value::Text(b)) => Ok(Value::Text(format!("{}{b}", a.as_display()))),
_ => bail!("`+` needs ints, nums, or text"),
},
BinaryOp::Sub => match (l, r) {
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a - b)),
(Value::Num(a), Value::Num(b)) => Ok(Value::Num(a - b)),
(Value::Int(a), Value::Num(b)) => Ok(Value::Num(*a as f64 - b)),
(Value::Num(a), Value::Int(b)) => Ok(Value::Num(a - *b as f64)),
_ => bail!("`-` needs ints or nums"),
},
BinaryOp::Mul => match (l, r) {
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a * b)),
(Value::Num(a), Value::Num(b)) => Ok(Value::Num(a * b)),
(Value::Int(a), Value::Num(b)) => Ok(Value::Num(*a as f64 * b)),
(Value::Num(a), Value::Int(b)) => Ok(Value::Num(a * *b as f64)),
_ => bail!("`*` needs ints or nums"),
},
BinaryOp::Div => match (l, r) {
(Value::Int(_), Value::Int(0)) => bail!("division by zero"),
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a / b)),
(Value::Num(_), Value::Num(b)) if *b == 0.0 => bail!("division by zero"),
(Value::Int(_), Value::Num(b)) if *b == 0.0 => bail!("division by zero"),
(Value::Num(_), Value::Int(0)) => bail!("division by zero"),
(Value::Num(a), Value::Num(b)) => Ok(Value::Num(a / b)),
(Value::Int(a), Value::Num(b)) => Ok(Value::Num(*a as f64 / b)),
(Value::Num(a), Value::Int(b)) => Ok(Value::Num(a / *b as f64)),
_ => bail!("`/` needs ints or nums"),
},
BinaryOp::Eq => Ok(Value::Bool(l == r)),
BinaryOp::Ne => Ok(Value::Bool(l != r)),
BinaryOp::Lt => cmp_ord(l, r, |o| o.is_lt()),
BinaryOp::Le => cmp_ord(l, r, |o| o.is_le()),
BinaryOp::Gt => cmp_ord(l, r, |o| o.is_gt()),
BinaryOp::Ge => cmp_ord(l, r, |o| o.is_ge()),
BinaryOp::And | BinaryOp::Or => unreachable!("handled above"),
}
}
fn cmp_ord(l: &Value, r: &Value, f: impl Fn(std::cmp::Ordering) -> bool) -> Result<Value> {
match (l, r) {
(Value::Int(a), Value::Int(b)) => Ok(Value::Bool(f(a.cmp(b)))),
(Value::Num(a), Value::Num(b)) => Ok(Value::Bool(f(a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)))),
(Value::Int(a), Value::Num(b)) => {
Ok(Value::Bool(f((*a as f64).partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))))
}
(Value::Num(a), Value::Int(b)) => {
Ok(Value::Bool(f(a.partial_cmp(&(*b as f64)).unwrap_or(std::cmp::Ordering::Equal))))
}
(Value::Text(a), Value::Text(b)) => Ok(Value::Bool(f(a.cmp(b)))),
_ => bail!("comparison needs two ints/nums or two texts"),
}
}
fn brief_trace_val(v: &Value) -> String {
let s = v.as_display();
if s.chars().count() > 24 {
format!("{}…", s.chars().take(24).collect::<String>())
} else {
s
}
}
/// Prefer real result; else last stdout line emitted by the call; else callee name.
fn call_event_brief(v: &Value, stdout: &str, stdout_before: usize, callee: &str) -> String {
if !matches!(v, Value::None) {
return brief_trace_val(v);
}
if stdout.len() > stdout_before {
let delta = &stdout[stdout_before..];
let line = delta
.trim_end()
.lines()
.last()
.unwrap_or(delta.trim_end());
if !line.is_empty() {
return if line.chars().count() > 48 {
format!("{}…", line.chars().take(48).collect::<String>())
} else {
line.to_string()
};
}
}
callee.to_string()
}
fn stmt_span(stmt: &Stmt) -> Span {
match stmt {
Stmt::Assign { span, .. }
| Stmt::Return { span, .. }
| Stmt::Call { span, .. }
| Stmt::Expr { span, .. }
| Stmt::Branch { span, .. }
| Stmt::While { span, .. }
| Stmt::ForEach { span, .. } => *span,
}
}