Implements RFC-EXT-0001 PR-00..PR-07 first pass: - CallSiteKey/CallBindingTable + one frontend binding pass; runtime dispatch by identity - prepare composition root shared by check/run/inspect/Analysis; exact plugin reconciliation - provider.json v2 --provider/--allow-provider worker CLI with fail-closed verification - capability handler registry with real fs.read and audit - verified stdlib public aliases replace print_override/AST scan - docs: specs, ADR-0054/0055/0057/0058, README, CI/release gates, evidence PR-04 extension selection/lock v4 and final frozen-binary evidence remain.
261 lines
8.1 KiB
Rust
261 lines
8.1 KiB
Rust
//! Official stdlib public alias routing (RFC-EXT-0001 §8, ADR-0058).
|
|
//!
|
|
//! `打印`/`print` are ordinary `Marqdo` bindings to `io.mq.md::写值` declared
|
|
//! in the verified `stdlib.json` metadata. There is no `print_override`, no
|
|
//! runtime name special case and no hard-coded per-function scan.
|
|
#![cfg(unix)]
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Command, Output};
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
|
|
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
|
|
|
struct TempDir(PathBuf);
|
|
|
|
impl TempDir {
|
|
fn new(tag: &str) -> Self {
|
|
let id = COUNTER.fetch_add(1, Ordering::Relaxed);
|
|
let path = std::env::temp_dir().join(format!(
|
|
"marqdo-stdlib-alias-test-{}-{id}-{tag}",
|
|
std::process::id()
|
|
));
|
|
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 repo() -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.parent()
|
|
.unwrap()
|
|
.parent()
|
|
.unwrap()
|
|
.to_path_buf()
|
|
}
|
|
|
|
fn cli(args: &[&str], dir: &Path, env: &[(&str, &Path)]) -> Output {
|
|
let mut command = Command::new(env!("CARGO_BIN_EXE_marqdo"));
|
|
command.args(args).current_dir(dir);
|
|
for (key, value) in env {
|
|
command.env(key, value);
|
|
}
|
|
command.output().unwrap()
|
|
}
|
|
|
|
fn stderr(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stderr).to_string()
|
|
}
|
|
|
|
fn stdout(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stdout).to_string()
|
|
}
|
|
|
|
fn copy_stdlib(target: &Path) {
|
|
let source = repo().join("stdlib");
|
|
std::fs::create_dir_all(target).unwrap();
|
|
for entry in std::fs::read_dir(&source).unwrap() {
|
|
let entry = entry.unwrap();
|
|
let path = entry.path();
|
|
if path.is_dir() {
|
|
copy_dir(&path, &target.join(entry.file_name()));
|
|
} else {
|
|
std::fs::copy(&path, target.join(entry.file_name())).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn copy_dir(source: &Path, target: &Path) {
|
|
std::fs::create_dir_all(target).unwrap();
|
|
for entry in std::fs::read_dir(source).unwrap() {
|
|
let entry = entry.unwrap();
|
|
let path = entry.path();
|
|
if path.is_dir() {
|
|
copy_dir(&path, &target.join(entry.file_name()));
|
|
} else {
|
|
std::fs::copy(&path, target.join(entry.file_name())).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn print_and_its_alias_are_bound_to_the_official_module() {
|
|
let dir = TempDir::new("print");
|
|
std::fs::write(
|
|
dir.path().join("index.mq.md"),
|
|
"## @exec main\n\n`打印(1)`\n\n`print(\"two\")`\n\n`return None`\n",
|
|
)
|
|
.unwrap();
|
|
let output = cli(&["run", "index.mq.md"], dir.path(), &[]);
|
|
assert_eq!(output.status.code(), Some(0), "{}", stderr(&output));
|
|
assert_eq!(stdout(&output), "1\ntwo\n");
|
|
}
|
|
|
|
#[test]
|
|
fn program_without_print_does_not_load_the_stdlib_module_graph() {
|
|
let dir = TempDir::new("no-print");
|
|
std::fs::write(
|
|
dir.path().join("index.mq.md"),
|
|
"## @exec main\n\n`params()`\n\n`return 1 + 2`\n",
|
|
)
|
|
.unwrap();
|
|
let analysis_path = dir.path().join("factorial.json");
|
|
let output = cli(
|
|
&[
|
|
"check",
|
|
"index.mq.md",
|
|
"--emit",
|
|
analysis_path.to_str().unwrap(),
|
|
],
|
|
dir.path(),
|
|
&[],
|
|
);
|
|
assert_eq!(output.status.code(), Some(0), "{}", stderr(&output));
|
|
let analysis: serde_json::Value =
|
|
serde_json::from_str(&std::fs::read_to_string(&analysis_path).unwrap()).unwrap();
|
|
let modules = analysis["modules"].as_array().unwrap();
|
|
assert!(
|
|
modules
|
|
.iter()
|
|
.all(|module| !module["id"].as_str().unwrap_or("").starts_with("std:")),
|
|
"a program without print must not load the stdlib: {analysis}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn print_program_loads_exactly_the_declared_alias_target() {
|
|
let dir = TempDir::new("with-print");
|
|
std::fs::write(
|
|
dir.path().join("index.mq.md"),
|
|
"## @exec main\n\n`打印(\"x\")`\n\n`return None`\n",
|
|
)
|
|
.unwrap();
|
|
let analysis_path = dir.path().join("hello.json");
|
|
let output = cli(
|
|
&[
|
|
"check",
|
|
"index.mq.md",
|
|
"--emit",
|
|
analysis_path.to_str().unwrap(),
|
|
],
|
|
dir.path(),
|
|
&[],
|
|
);
|
|
assert_eq!(output.status.code(), Some(0), "{}", stderr(&output));
|
|
let analysis: serde_json::Value =
|
|
serde_json::from_str(&std::fs::read_to_string(&analysis_path).unwrap()).unwrap();
|
|
let ids: Vec<&str> = analysis["modules"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.filter_map(|module| module["id"].as_str())
|
|
.collect();
|
|
assert!(
|
|
ids.iter().any(|id| id.ends_with("::io.mq.md")),
|
|
"print must load io.mq.md: {ids:?}"
|
|
);
|
|
assert!(
|
|
ids.iter().any(|id| id.ends_with("::format.mq.md")),
|
|
"io.mq.md imports format.mq.md: {ids:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn tampered_public_alias_metadata_digest_is_rejected() {
|
|
let dir = TempDir::new("alias-digest");
|
|
let stdlib = dir.path().join("stdlib");
|
|
copy_stdlib(&stdlib);
|
|
let manifest_path = stdlib.join("stdlib.json");
|
|
let text = std::fs::read_to_string(&manifest_path).unwrap();
|
|
let mut manifest: serde_json::Value = serde_json::from_str(&text).unwrap();
|
|
manifest["aliases_digest"] = serde_json::json!("sha256:".to_string() + &"0".repeat(64));
|
|
std::fs::write(
|
|
&manifest_path,
|
|
serde_json::to_string_pretty(&manifest).unwrap() + "\n",
|
|
)
|
|
.unwrap();
|
|
let doc = dir.path().join("index.mq.md");
|
|
std::fs::write(&doc, "## @exec main\n\n`打印(1)`\n\n`return None`\n").unwrap();
|
|
let output = cli(
|
|
&["run", doc.to_str().unwrap()],
|
|
dir.path(),
|
|
&[("MARQDO_STDLIB_DIR", &stdlib)],
|
|
);
|
|
assert!(!output.status.success(), "{}", stderr(&output));
|
|
assert!(
|
|
stderr(&output).contains("public-alias metadata digest mismatch"),
|
|
"{}",
|
|
stderr(&output)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn tampered_alias_target_signature_is_rejected() {
|
|
let dir = TempDir::new("alias-target");
|
|
let stdlib = dir.path().join("stdlib");
|
|
copy_stdlib(&stdlib);
|
|
let manifest_path = stdlib.join("stdlib.json");
|
|
let text = std::fs::read_to_string(&manifest_path).unwrap();
|
|
let mut manifest: serde_json::Value = serde_json::from_str(&text).unwrap();
|
|
manifest["public_aliases"][0]["expected_signature"] = serde_json::json!("params(值, 额外)");
|
|
// Recompute the declared metadata digest so only the target check can fail.
|
|
let canonical = manifest["public_aliases"][0].clone();
|
|
let module = canonical["target_module"].as_str().unwrap();
|
|
let function = canonical["target_function"].as_str().unwrap();
|
|
let mut names: Vec<&str> = canonical["public_names"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.filter_map(serde_json::Value::as_str)
|
|
.collect();
|
|
names.sort();
|
|
use sha2::{Digest, Sha256};
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(module.as_bytes());
|
|
hasher.update([0]);
|
|
hasher.update(function.as_bytes());
|
|
hasher.update([0]);
|
|
for name in names {
|
|
hasher.update(name.as_bytes());
|
|
hasher.update([0]);
|
|
}
|
|
let digest = format!("sha256:{}", hex(&hasher.finalize()));
|
|
manifest["aliases_digest"] = serde_json::json!(digest);
|
|
std::fs::write(
|
|
&manifest_path,
|
|
serde_json::to_string_pretty(&manifest).unwrap() + "\n",
|
|
)
|
|
.unwrap();
|
|
let doc = dir.path().join("index.mq.md");
|
|
std::fs::write(&doc, "## @exec main\n\n`打印(1)`\n\n`return None`\n").unwrap();
|
|
let output = cli(
|
|
&["run", doc.to_str().unwrap()],
|
|
dir.path(),
|
|
&[("MARQDO_STDLIB_DIR", &stdlib)],
|
|
);
|
|
assert!(!output.status.success(), "{}", stderr(&output));
|
|
assert!(
|
|
stderr(&output).contains("expected signature") || stderr(&output).contains("alias"),
|
|
"{}",
|
|
stderr(&output)
|
|
);
|
|
}
|
|
|
|
fn hex(bytes: &[u8]) -> String {
|
|
let mut out = String::with_capacity(bytes.len() * 2);
|
|
for byte in bytes {
|
|
out.push_str(&format!("{byte:02x}"));
|
|
}
|
|
out
|
|
}
|