Files
marqdo/src/source_refinement_tests.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

453 lines
18 KiB
Rust
Executable File

//! Export the actual loaded AST and independently observe both real backends.
//! Unsupported AST constructs are errors, never omitted or normalized to no-op.
use crate::ast::{Arg, BinaryOp, CallExpr, Expr, Function, Literal, Module, Stmt};
use crate::host::{foreign_session, json::value_to_json, HostContext};
use crate::value::Value;
use serde_json::{json, Value as Json};
use sha2::{Digest, Sha256};
use std::path::PathBuf;
pub(crate) fn boundary_evidence(
ctx: &mut HostContext,
) -> (Vec<Value>, Vec<Value>, Vec<foreign_session::ProtocolStep>) {
let observations = ctx.oracle_observations.clone();
let protocol = ctx.foreign_protocol_steps.clone();
let mut ids = ctx.foreign_sessions.keys().cloned().collect::<Vec<_>>();
ids.sort();
// These verification reads bypass the document observation API. They occur
// only after its journal was captured, and never alter that journal.
let values = ids
.iter()
.map(|id| {
foreign_session::get(ctx, &Value::Handle(id.clone()), &Value::Text("n".into())).unwrap()
})
.collect();
assert_eq!(observations, ctx.oracle_observations);
(observations, values, protocol)
}
fn expr(e: &Expr) -> Result<Json, String> {
Ok(match e {
Expr::Literal(Literal::None) => json!(["literal", null]),
Expr::Literal(Literal::Bool(b)) => json!(["literal", b]),
Expr::Literal(Literal::Int(n)) => json!(["literal", n]),
Expr::Literal(Literal::Text(s)) => json!(["literal", s]),
Expr::Var(name) => json!(["var", name]),
Expr::Binary { op, left, right } => {
let tag = match op {
BinaryOp::Add => "add",
BinaryOp::Sub => "sub",
BinaryOp::Lt => "lt",
_ => return Err(format!("unsupported source binary op {op:?}")),
};
json!([tag, expr(left)?, expr(right)?])
}
_ => return Err(format!("unsupported source expression {e:?}")),
})
}
fn call(c: &CallExpr, dest: Option<&str>, defs: &[&Function]) -> Result<Json, String> {
if c.receiver.is_some() || !c.pre_modifiers.is_empty() {
return Err("unsupported receiver/modifiers".into());
}
if let Some(path) = &c.path {
if path.len() != 2 || path[0] != "foreign" {
return Err(format!("unsupported library path {path:?}"));
}
let mut args = std::collections::BTreeMap::new();
for a in &c.args {
let Arg::Named { name, value } = a else {
return Err("foreign primitive needs named arguments".into());
};
if args.insert(name.as_str(), value).is_some() {
return Err("duplicate argument".into());
}
}
let allowed: &[&str] = match path[1].as_str() {
"session_open" => &["lang"],
"session_set" => &["id", "name", "value"],
"session_get" => &["id", "name"],
"session_eval" => &["id", "source", "input", "stdin"],
"session_close" => &["id"],
_ => return Err(format!("unsupported primitive {path:?}")),
};
if args.keys().any(|k| !allowed.contains(k)) {
return Err("unsupported primitive option".into());
}
let arg = |name: &str| {
args.get(name)
.copied()
.ok_or_else(|| format!("missing {name}"))
};
let name = || match arg("name")? {
Expr::Literal(Literal::Text(s)) => Ok(s.clone()),
_ => Err("dynamic binding name unsupported".to_string()),
};
match path[1].as_str() {
"session_open" => Ok(json!([
"open",
dest.ok_or("open destination required")?,
expr(arg("lang")?)?
])),
"session_get" => Ok(json!([
"get",
dest.ok_or("get destination required")?,
expr(arg("id")?)?,
name()?
])),
_ if dest.is_some() => {
Err("assigned set/eval/close record requires a richer adapter".into())
}
"session_set" => Ok(json!([
"set",
expr(arg("id")?)?,
name()?,
expr(arg("value")?)?
])),
"session_eval" => Ok(json!([
"eval",
expr(arg("id")?)?,
expr(arg("source")?)?,
args.get("input")
.map(|v| expr(v))
.transpose()?
.unwrap_or(json!(["literal", null])),
args.get("stdin").map(|v| expr(v)).transpose()?
])),
"session_close" => Ok(json!(["close", expr(arg("id")?)?])),
_ => unreachable!(),
}
} else {
let f = defs
.iter()
.find(|f| f.name == c.callee)
.ok_or_else(|| format!("unknown function {}", c.callee))?;
let mut values = std::collections::BTreeMap::new();
let mut positional = 0;
for a in &c.args {
let (name, value) = match a {
Arg::Named { name, value } => (name.as_str(), value),
Arg::Positional(value) => {
let p = f.params.get(positional).ok_or("too many arguments")?;
positional += 1;
(p.name.as_str(), value)
}
};
if !f.params.iter().any(|p| p.name == name) || values.insert(name, value).is_some() {
return Err("invalid call argument".into());
}
}
let ordered = f
.params
.iter()
.map(|p| expr(values.get(p.name.as_str()).ok_or("missing parameter")?))
.collect::<Result<Vec<_>, _>>()?;
Ok(json!(["call", dest, c.callee, ordered]))
}
}
fn block(body: &[Stmt], defs: &[&Function]) -> Result<Vec<Json>, String> {
body.iter()
.map(|s| {
Ok(match s {
Stmt::Assign {
name,
value: Expr::Call(c),
..
} => call(c, Some(name), defs)?,
Stmt::Assign { name, value, .. } => json!(["assign", name, expr(value)?]),
Stmt::Return { value, .. } => json!(["return", expr(value)?]),
Stmt::Call { call: c, .. } => call(c, None, defs)?,
Stmt::While {
condition, body, ..
} => json!(["while", expr(condition)?, block(body, defs)?]),
Stmt::Branch { arms, .. } => {
let mut rest = Vec::new();
for (i, arm) in arms.iter().enumerate().rev() {
let body = block(&arm.body, defs)?;
if let Some(condition) = &arm.condition {
rest = vec![json!(["if", expr(condition)?, body, rest])];
} else {
if i != arms.len() - 1 {
return Err("nonterminal else".into());
}
rest = body;
}
}
if rest.len() != 1 || rest[0][0] != "if" {
return Err("branch needs condition".into());
}
rest.pop().unwrap()
}
_ => return Err(format!("unsupported source statement {s:?}")),
})
})
.collect()
}
fn source_ir(module: &Module) -> Result<Json, String> {
if module.functions.len() != 1 || !module.uses.is_empty() {
return Err("module needs the declared single-entry adapter".into());
}
let main = module
.functions
.iter()
.find(|f| f.name == "main")
.ok_or("missing main")?;
let defs = main.children.iter().collect::<Vec<_>>();
if !main.params.is_empty() {
return Err("entry parameters need an explicit environment adapter".into());
}
let mut seen = std::collections::HashSet::new();
for f in &defs {
if !seen.insert(&f.name)
|| !f.children.is_empty()
|| f.params.iter().any(|p| p.default.is_some())
{
return Err("unsupported function scope/default".into());
}
}
let functions = defs.iter().map(|f| Ok(json!({"name":f.name,"params":f.params.iter().map(|p|p.name.clone()).collect::<Vec<_>>(),"body":block(&f.body,&defs)?}))).collect::<Result<Vec<_>,String>>()?;
let initial = module
.metadata
.iter()
.map(|(name, value)| {
if !matches!(
value,
Value::None | Value::Bool(_) | Value::Int(_) | Value::Text(_)
) {
return Err("non-scalar metadata needs an explicit initial-value adapter".into());
}
Ok(json!([name, value_to_json(value)?]))
})
.collect::<Result<Vec<_>, String>>()?;
Ok(json!({"initial":initial,"entry":block(&main.body,&defs)?,"functions":functions}))
}
fn source(lang: &str, seed: i64, rounds: usize, scenario: &str) -> String {
let increment = "n += 1; n";
let bad = "n = 99; 9007199254740992";
let stdin = if scenario == "explicit_empty_stdin" {
" stdin=\"\""
} else {
""
};
let condition = if scenario == "else_branch" {
seed - 1
} else {
seed + 1
};
let function = match scenario {
"recursive" => "advance_rec",
"early_return" => "early",
_ => "adjust",
};
let failure = match scenario {
"closed_get" => "**> foreign.session_close id=`alias`**\n**lost = > foreign.session_get id=`alias` name=\"n\"**".into(),
"copy_handle" => "**> foreign.session_set id=`a` name=\"n\" value=`b`**".into(),
"closed_copy" => "**> foreign.session_close id=`alias`**\n**> foreign.session_set id=`alias` name=\"n\" value=`b`**".into(),
"wide_input" => "**> foreign.session_set id=`a` name=\"n\" value=9007199254740992**".into(),
"wide_output" => format!("**> foreign.session_eval id=`a` source=\"{bad}\"**"),
_ => String::new(),
};
format!(
r#"---
markup: occlusion
import:
foreign: lib/foreign.mq.md
---
# main
**a = > foreign.session_open lang="{lang}"**
**b = > foreign.session_open lang="{lang}"**
**> foreign.session_set id=`a` name="n" value={seed}**
**> foreign.session_set id=`b` name="n" value=100**
**alias = `a`**
**counter = 777**
**before = > foreign.session_get id=`a` name="n"**
{failure}
1. `before` < {condition}
**answer = > {function} s=`alias` rounds={rounds}**
2. *
**> foreign.session_set id=`a` name="n" value={else_value}**
**after = > foreign.session_get id=`a` name="n"**
**peer = > foreign.session_get id=`b` name="n"**
**> foreign.session_close id=`alias`**
**c = > foreign.session_open lang="{lang}"**
**> foreign.session_set id=`c` name="n" value=7**
**fresh = > foreign.session_get id=`c` name="n"**
**> foreign.session_close id=`b`**
**> foreign.session_close id=`c`**
**total = after + peer + fresh + counter**
*total*
## adjust
+ `s`
+ `rounds`
**counter = 0**
- `counter` < `rounds`
> bump s=`s`
**counter = counter + 1**
**answer = > foreign.session_get id=`s` name="n"**
*answer*
## bump
+ `s`
> foreign.session_eval id=`s` source="{increment}"{stdin}
## advance_rec
+ `s`
+ `rounds`
1. 0 < `rounds`
> bump s=`s`
**remaining = rounds - 1**
**answer = > advance_rec s=`s` rounds=`remaining`**
*answer*
2. *
**answer = > foreign.session_get id=`s` name="n"**
*answer*
## early
+ `s`
+ `rounds`
**counter = 0**
- `counter` < `rounds`
**answer = > foreign.session_get id=`s` name="n"**
*answer*
**answer = > foreign.session_get id=`s` name="n"**
*answer*
"#,
else_value = seed + 20
)
}
#[test]
fn parsed_source_control_matches_independent_oracles_on_both_backends() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::var_os("MARQDO_SOURCE_ARTIFACT_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| root.join("target/source-refinement"));
std::fs::create_dir_all(&out).unwrap();
let seeds = std::env::var("MARQDO_SOURCE_SEEDS")
.unwrap_or("3".into())
.split(',')
.map(|x| x.parse::<i64>().unwrap())
.collect::<Vec<_>>();
let lengths = std::env::var("MARQDO_SOURCE_ROUNDS")
.unwrap_or("0,3".into())
.split(',')
.map(|x| x.parse::<usize>().unwrap())
.collect::<Vec<_>>();
let scenarios = [
"normal",
"recursive",
"early_return",
"else_branch",
"closed_get",
"copy_handle",
"closed_copy",
"wide_input",
"wide_output",
"explicit_empty_stdin",
];
let mut count = 0;
for lang in ["python", "node"] {
for &seed in &seeds {
for &rounds in &lengths {
for scenario in scenarios {
let id = format!("{lang}-{seed}-{rounds}-{scenario}");
let text = source(lang, seed, rounds, scenario);
// Absolute import is only a fixture location; the actual module is loaded.
let text = text.replace(
"foreign: lib/foreign.mq.md",
&format!("foreign: {}", root.join("lib/foreign.mq.md").display()),
);
let path = out.join(format!("{id}.mq.md"));
std::fs::write(&path, &text).unwrap();
let module = crate::load::load_module(&path).unwrap();
let ir = source_ir(&module).unwrap_or_else(|e| panic!("{id}: AST export: {e}"));
let mut executions = Vec::new();
for backend in ["tree", "bytecode"] {
let (result, journal, values, protocol) = if backend == "tree" {
let mut interpreter =
crate::interp::Interpreter::with_capture(Some(&path), false);
let result = interpreter.run_module(&module);
let (journal, values, protocol) = interpreter.foreign_source_evidence();
assert!(interpreter.captured_stdout.is_empty(), "unexpected stdout");
(result, journal, values, protocol)
} else {
let code =
crate::bytecode::compile_module(Some(&path), &module).unwrap();
let mut vm = crate::bytecode::Vm::with_capture(Some(&path));
let result = vm.run(&code);
let (journal, values, protocol) = vm.foreign_source_evidence();
assert!(vm.captured_stdout.is_empty(), "unexpected stdout");
(result, journal, values, protocol)
};
let failure = matches!(
scenario,
"closed_get"
| "copy_handle"
| "closed_copy"
| "wide_input"
| "wide_output"
);
assert_eq!(result.is_err(), failure, "{id} {backend}: {result:?}");
if !failure {
let expected = seed
+ if scenario == "early_return" {
0
} else if scenario == "else_branch" {
20
} else {
rounds as i64
};
assert_eq!(
result.as_ref().unwrap(),
&Value::Int(expected + 884),
"{id} {backend}"
);
}
let error = result.as_ref().err().map(|e| e.to_string());
let diagnostic = result.as_ref().err().and_then(crate::diagnostics::Diagnostic::find).map(crate::diagnostics::Diagnostic::to_json);
let fault = if let Some(e) = &error {
if e.contains("not found") {
"unknown"
} else if e.contains("outside V_safe")
|| e.contains("cannot be serialized")
{
if protocol.last().is_some_and(|p| {
p.response.as_ref().is_ok_and(|reply| {
reply.get("domain_error").and_then(Json::as_bool)
== Some(true)
})
}) {
"outputDomain"
} else {
"inputDomain"
}
} else {
panic!("{id} {backend}: unclassified error {e}")
}
} else {
"none"
};
let protocol = protocol.iter().map(|p| json!({"session":p.session,"request":p.request,"response":p.response})).collect::<Vec<_>>();
executions.push(json!({"backend":backend,"ok":result.is_ok(),"result":result.ok().map(|v|value_to_json(&v).unwrap()),"error":error,"fault":fault,"protocol":protocol,"diagnostic":diagnostic,
"journal":value_to_json(&Value::List(journal)).unwrap(),"live_values":value_to_json(&Value::List(values)).unwrap()}));
}
std::fs::write(out.join(format!("{id}.json")),serde_json::to_vec_pretty(&json!({"version":1,"id":id,"language":lang,"seed":seed,"rounds":rounds,"scenario":scenario,"source_sha256":format!("{:x}",Sha256::digest(text.as_bytes())),"ast":ir,"executions":executions})).unwrap()).unwrap();
count += 1;
}
}
}
}
println!(
"SOURCE_METRIC:{}",
json!({"cases":count,"executions":count*2,"scenarios":scenarios,"correct":true})
);
}