Files
cflmy e029853e32 feat(lang): implement RFC-LANG-0002 unified semantics (breaking)
One Markdown-to-program mapping, no version selector or legacy mapper.

Frontend/runtime:
- resolve @exec/@knowledge heading declarations with nearest-ancestor
  inheritance; only an Exec H2 is callable; add UnitKind::Knowledge and
  sem.* diagnostics (mode marker, unit name, exec-without-function,
  payload nesting/empty, syntax, control stack, params position,
  version directive, inferred-signature lint)
- extract Strong/Emph/inline Code as one-statement carriers, refuse
  nested carriers, and honour heading segment boundaries so an if/while
  cannot be closed across a heading
- lower if/else/while/end to the existing Branch/Loop/Return IR with a
  compile-time control stack; keep payload-relative source spans through
  expression parsing and rewrite them onto the file
- accept params(...) only as the first direct Exec H2 payload; keep the
  existing free-variable inference and named-only rule for inferred
  signatures; fix duplicate-mode/else/end and Knowledge-body inertness
- reject marqdo_semantics/syntax front matter directives

Data and tests:
- migrate stdlib/**/*.mq.md, regenerate stdlib.json digest
- migrate examples and the full semantics/negative/runtime corpus to
  the only current syntax; expected values/runtime codes preserved
- migrate Rust-embedded .mq.md fixtures, init template, CLI help and
  security-lane fixtures

Verified: cargo fmt --check, cargo clippy -D warnings and
cargo test --workspace --locked (green).
2026-11-21 12:26:46 +08:00

112 lines
3.3 KiB
Rust

//! Compat-B `打印` routing tests (ADR-0030).
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
struct TempDir(PathBuf);
impl TempDir {
fn new(tag: &str) -> Self {
let path =
std::env::temp_dir().join(format!("marqdo-print-route-{}-{tag}", std::process::id()));
let _ = std::fs::remove_dir_all(&path);
std::fs::create_dir_all(&path).unwrap();
Self(path)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
fn cli(dir: &Path, args: &[&str]) -> Output {
Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(args)
.current_dir(dir)
.output()
.expect("run marqdo")
}
fn write(dir: &Path, name: &str, source: &str) -> PathBuf {
let path = dir.join(name);
std::fs::write(&path, source).unwrap();
path
}
#[test]
fn print_is_routed_through_the_stdlib_and_not_hostop_print() {
let dir = TempDir::new("routed");
write(
dir.path(),
"index.mq.md",
"## @exec main\n\n`打印([\"x\", 1])`\n\n`return None`\n",
);
let trace = dir.path().join("trace.json");
let output = cli(
dir.path(),
&[
"run",
"index.mq.md",
"--trace-file",
trace.to_str().unwrap(),
],
);
assert_eq!(
output.status.code(),
Some(0),
"{}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(String::from_utf8_lossy(&output.stdout), "[\"x\", 1]\n");
let trace: serde_json::Value = serde_json::from_slice(&std::fs::read(&trace).unwrap()).unwrap();
let operations: Vec<&str> = trace["events"]
.as_array()
.unwrap()
.iter()
.filter_map(|event| event["operation"].as_str())
.collect();
assert!(
operations.contains(&"resource.write"),
"stdlib print must write through the resource ABI: {operations:?}"
);
assert!(
!operations.contains(&"print"),
"legacy HostOp::Print must not run in Compat-B: {operations:?}"
);
}
#[test]
fn stdlib_print_modules_are_injected_only_when_print_is_used() {
let dir = TempDir::new("lazy");
write(dir.path(), "plain.mq.md", "## @exec main\n\n`return 1`\n");
write(
dir.path(),
"prints.mq.md",
"## @exec main\n\n`打印(1)`\n\n`return None`\n",
);
for (file, expected_stdlib) in [("plain.mq.md", false), ("prints.mq.md", true)] {
let target = dir.path().join(format!("{file}.json"));
let output = cli(
dir.path(),
&["check", file, "--emit", target.to_str().unwrap()],
);
assert_eq!(output.status.code(), Some(0), "{file}");
let analysis: serde_json::Value =
serde_json::from_slice(&std::fs::read(&target).unwrap()).unwrap();
let modules = analysis["modules"].as_array().unwrap();
let has_stdlib = modules
.iter()
.any(|module| module["id"].as_str().unwrap_or("").starts_with("std:"));
assert_eq!(has_stdlib, expected_stdlib, "{file}: {modules:?}");
// The bundle identity is recorded whenever a bundle is available; it
// does not imply that this program loaded any stdlib module.
assert!(analysis["project"]["stdlib"].is_object(), "{file}");
}
}