Files
marqdo/src/prove/mod.rs
T

890 lines
31 KiB
Rust
Executable File
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.
//! `marqdo prove`:SKILL 控制平面 → Lean 4(`doc/design/prove-cli.md`)。
//!
//! 三条契约(设计 §1.3):
//! 1. **诚实**——只报实际做过的判定;`checked` 永不冒充 Lean 结论;
//! 2. **单调**——离线判定严格弱于 Lean(P2 落地护栏);
//! 3. **不执行**——本模块只读源码,从不运行目标程序。
//!
//! P0 范围(roadmap/prove.md §2):装载 → 降级 → 定型 → 确定性生成 + audit。
//! 判定(离线 ⑤ / Lean ⑥)在 P1/P2 接入;状态只到 `unverified` / `rejected` /
//! `error`。
pub mod cache;
pub mod driver;
pub mod emit;
pub mod ir;
pub mod lower;
pub mod offline;
pub mod proof_check;
pub mod types;
use std::path::{Path, PathBuf};
use std::time::Instant;
use anyhow::{Context, Result};
use crate::diagnostics::Diagnostic;
use crate::prove::lower::Lowered;
/// 判定层级(P0 恒 `none`)。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tier {
Lean,
Offline,
None,
}
impl Tier {
pub fn as_str(self) -> &'static str {
match self {
Tier::Lean => "lean",
Tier::Offline => "offline",
Tier::None => "none",
}
}
}
/// 状态词(§1.2;P0 只会产生 `unverified` / `rejected` / `error`)。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Verdict {
Proved,
Checked,
Unverified,
Unproved,
Rejected,
Error,
}
impl Verdict {
pub fn as_str(self) -> &'static str {
match self {
Verdict::Proved => "proved",
Verdict::Checked => "checked",
Verdict::Unverified => "unverified",
Verdict::Unproved => "unproved",
Verdict::Rejected => "rejected",
Verdict::Error => "error",
}
}
/// 聚合优先级(差者胜):error > unproved > rejected > unverified > checked > proved。
pub fn rank(self) -> u8 {
match self {
Verdict::Proved => 0,
Verdict::Checked => 1,
Verdict::Unverified => 2,
Verdict::Rejected => 3,
Verdict::Unproved => 4,
Verdict::Error => 5,
}
}
pub fn worst(a: Verdict, b: Verdict) -> Verdict {
if a.rank() >= b.rank() {
a
} else {
b
}
}
}
/// 退出码(§3.3)。
impl Verdict {
pub fn exit_code(self, require_lean: bool) -> i32 {
match self {
Verdict::Error => 1,
Verdict::Unproved => 1,
Verdict::Rejected | Verdict::Unverified | Verdict::Checked if require_lean => 2,
_ => 0,
}
}
}
/// 选项(§8.2)。
#[derive(Debug, Clone)]
pub struct ProveOptions {
pub entry: Option<String>,
pub only: Vec<String>,
pub allow_opaque: Vec<String>,
pub emit_dir: Option<PathBuf>,
pub strict_types: bool,
pub require_lean: bool,
pub report_only: bool,
/// 绕过证书缓存(`--no-cache` / `MARQDO_PROOF_NO_CACHE`)。
pub no_cache: bool,
/// 显式 lean 路径(`--lean` / `MARQDO_PROOF_LEAN`)。
pub lean: Option<PathBuf>,
/// 单次 lean 调用超时(默认 120s)。
pub timeout: std::time::Duration,
/// 是否执行判定(`prove emit`/`audit` 子命令 = false,只生成不证)。
pub judge: bool,
/// `maxHeartbeats`(默认随 lean)。
pub max_heartbeats: Option<u64>,
}
impl Default for ProveOptions {
fn default() -> Self {
Self {
entry: None,
only: Vec::new(),
allow_opaque: Vec::new(),
emit_dir: None,
strict_types: true,
require_lean: false,
report_only: false,
no_cache: false,
lean: None,
timeout: std::time::Duration::from_secs(120),
judge: true,
max_heartbeats: None,
}
}
}
/// 单条定理的判定面(§3.5 claims)。
#[derive(Debug, Clone)]
pub struct ClaimReport {
pub id: String,
pub premise: Option<String>,
pub conclusion: String,
pub tactic: Option<String>,
/// `proved` / `unproved` / `unverified`(判定层给出前与函数一致)。
pub status: Verdict,
/// `trace`(P2 离线)/ `lean` / 空(未判定)。
pub decided_by: String,
/// 映射回 `.mq.md` 的行号(失败证据)。
pub source_line: Option<u32>,
/// Lean 原始报错片段(unproved 时)。
pub evidence: Option<String>,
}
/// 单函数报告。
#[derive(Debug, Clone)]
pub struct FunctionReport {
pub name: String,
pub verdict: Verdict,
pub tier: Tier,
/// 不透明操作(id, effect)。
pub ops: Vec<(String, String)>,
/// 拒绝原因(code, message, line)。
pub rejected: Vec<(String, String, u32)>,
/// 定理声明 + 判定。
pub claims: Vec<ClaimReport>,
}
/// Lean 判定信息(`lean: null` 表示没跑)。
#[derive(Debug, Clone)]
pub struct LeanInfo {
pub toolchain: String,
pub library_sha256: String,
pub module_sha256: String,
/// `hit` / `miss`。
pub cache: &'static str,
}
/// 整体报告。
#[derive(Debug, Clone)]
pub struct Report {
pub file: String,
pub source_sha256: String,
/// 产物目录 id(`.marqdo/prove/<artifact_id>`)。
pub artifact_id: Option<String>,
pub status: Verdict,
pub functions: Vec<FunctionReport>,
pub diagnostics: Vec<Diagnostic>,
pub emitted: Vec<PathBuf>,
pub lean: Option<LeanInfo>,
pub duration_ms: u128,
}
impl Report {
/// JSON 面(§3.5;`status` 枚举稳定)。
pub fn to_json(&self) -> serde_json::Value {
use serde_json::json;
json!({
"schema": 1,
"status": self.status.as_str(),
"file": self.file,
"source_sha256": self.source_sha256,
"artifact_id": match &self.artifact_id {
Some(id) => json!(format!("mq://prove/{id}")),
None => serde_json::Value::Null,
},
"functions": self.functions.iter().map(|f| json!({
"name": f.name,
"status": f.verdict.as_str(),
"tier": f.tier.as_str(),
"claims": f.claims.iter().map(|c| {
let mut j = json!({
"id": c.id,
"premise": c.premise,
"conclusion": c.conclusion,
"tactic": c.tactic,
"status": c.status.as_str(),
});
if !c.decided_by.is_empty() {
j["decided_by"] = json!(c.decided_by);
}
if let Some(line) = c.source_line {
j["line"] = json!(line);
}
if let Some(ev) = &c.evidence {
j["evidence"] = json!(ev);
}
j
}).collect::<Vec<_>>(),
"obligations": [],
"ops": f.ops.iter().map(|(id, effect)| json!({
"id": id, "effect": effect,
})).collect::<Vec<_>>(),
"rejected": f.rejected.iter().map(|(code, message, line)| json!({
"code": code, "message": message, "line": line,
})).collect::<Vec<_>>(),
})).collect::<Vec<_>>(),
"lean": match &self.lean {
Some(info) => json!({
"toolchain": info.toolchain,
"library_sha256": info.library_sha256,
"module_sha256": info.module_sha256,
"cache": info.cache,
}),
None => serde_json::Value::Null,
},
"assumptions": [],
"diagnostics": self.diagnostics.iter().map(|d| d.to_json()).collect::<Vec<_>>(),
"emitted": self.emitted.iter().map(|p| p.display().to_string()).collect::<Vec<_>>(),
"duration_ms": self.duration_ms as u64,
})
}
/// 文本面(§3.4 风格;诊断走 stderr 由 main 负责)。
pub fn to_text(&self) -> String {
let mut out = String::new();
let functions = self.functions.len();
let rejected = self
.functions
.iter()
.filter(|f| f.verdict == Verdict::Rejected)
.count();
let ops: usize = self.functions.iter().map(|f| f.ops.len()).sum();
out.push_str(&format!("prove: {}\n", self.file));
let cache_note = match &self.lean {
Some(info) => format!("(lean · cache: {})", info.cache),
None => String::new(),
};
out.push_str(&format!(
" status: {}{}\n",
self.status.as_str(),
cache_note
));
out.push_str(&format!(
" functions: {functions} · opaque ops: {ops} · rejected: {rejected}\n"
));
for f in &self.functions {
if f.verdict == Verdict::Rejected {
let codes: Vec<&str> = f.rejected.iter().map(|(c, _, _)| c.as_str()).collect();
out.push_str(&format!(" rejected: {} ({})\n", f.name, codes.join(", ")));
}
for c in &f.claims {
match (c.status, &c.evidence) {
(Verdict::Proved, _) => {
out.push_str(&format!(" proved: {}.{}\n", f.name, c.id));
}
(Verdict::Unproved, Some(ev)) => {
let line = c
.source_line
.map(|l| format!(":{l}"))
.unwrap_or_default();
out.push_str(&format!(
" unproved: {}.{line}{} — {}\n",
f.name,
c.id,
first_line(ev)
));
}
(Verdict::Unverified, _) => {
out.push_str(&format!(" unverified: {}.{}\n", f.name, c.id));
}
_ => {}
}
}
}
for p in &self.emitted {
out.push_str(&format!(" emitted: {}\n", p.display()));
}
out
}
}
fn first_line(s: &str) -> String {
s.lines().next().unwrap_or("").to_string()
}
/// P0 主入口:装载 → 降级 → 定型 → 生成。
pub fn prove_path(path: &Path, opts: &ProveOptions) -> Result<Report> {
let started = Instant::now();
let module = crate::load::load_module(path)
.with_context(|| format!("装载 {}", path.display()))?;
let source_sha256 = module
.source
.sha256
.clone()
.unwrap_or_default();
let file_display = display_path(path);
// ① 装载完成;② 降级(效应表来自 sema;失败时保守 unknown)。
let effects = lower::effect_map(path);
let (plan, lowered) = lower::build_plan(
&module,
&source_sha256,
&file_display,
effects,
&opts.allow_opaque,
)?;
// ③ 定型(分支合流等;错误码 proof.type_mismatch)。
let mut diagnostics: Vec<Diagnostic> = Vec::new();
diagnostics.extend(types::typecheck_plan(&module, &lowered, opts.strict_types));
// ④ 生成(--report-only 时跳过写盘)。
let mut emitted: Vec<PathBuf> = Vec::new();
let mut artifact_dir: Option<PathBuf> = None;
let mut generated_lean: Option<(PathBuf, String)> = None;
if !opts.report_only {
let dir = match &opts.emit_dir {
Some(dir) => dir.clone(),
None => default_emit_dir(&source_sha256),
};
let generated = dir.join("Generated");
std::fs::create_dir_all(&generated)
.with_context(|| format!("创建 {}", generated.display()))?;
let (file_name, lean) = emit::emit_module(&plan, &emit::stem_of(&file_display));
let lean_path = generated.join(&file_name);
std::fs::write(&lean_path, &lean)
.with_context(|| format!("写入 {}", lean_path.display()))?;
let plan_path = dir.join("plan.json");
std::fs::write(&plan_path, plan.to_stable_json())
.with_context(|| format!("写入 {}", plan_path.display()))?;
emitted.push(relative_cwd(&lean_path));
emitted.push(relative_cwd(&plan_path));
artifact_dir = Some(dir.clone());
generated_lean = Some((lean_path, lean));
}
// 汇总:错误诊断 → error;有拒绝函数 → rejected;否则 unverified。
let has_type_errors = diagnostics
.iter()
.any(|d| matches!(d.severity, crate::diagnostics::Severity::Error));
let mut functions = summarize(&lowered, &opts.only);
let mut status = Verdict::Unverified;
if !functions.is_empty() {
status = functions
.iter()
.map(|f| f.verdict)
.fold(Verdict::Proved, Verdict::worst);
}
if has_type_errors {
status = Verdict::Error;
}
// ⑤ 判定(P2):离线符号执行先行(毫秒级,checked ≠ proved),
// 有 Lean 工具链时随即复核(checked 升 proved;分歧 → error,永不落绿)。
let mut lean_info: Option<LeanInfo> = None;
let claims_present = plan.functions.iter().any(|f| !f.claims.is_empty());
if claims_present && opts.judge && !opts.report_only {
// ⑤a 离线(§5):F1–F5 片段内给 checked/反例,超出片段不猜。
judge_offline(&plan, &mut functions, &mut diagnostics);
// ⑤b Lean 复核(§8):证书缓存 → 现算。
match judge_with_lean(
&plan,
&source_sha256,
artifact_dir.as_deref(),
&generated_lean,
opts,
&mut functions,
&mut diagnostics,
) {
Ok((verdict, info)) => {
lean_info = info;
if let Some(v) = verdict {
status = v;
}
}
Err(err) => {
diagnostics.push(
Diagnostic::new(None, crate::diagnostics::Span::new(0, 0), format!("{err:#}"))
.with_code("proof.lean_error"),
);
status = Verdict::Error;
}
}
} else if claims_present && opts.report_only {
// report-only:不判定、不写盘;未证状态如实保留(恒返回 0 由 exit_code 处理)。
}
// 函数级状态聚合(判定后重算):文件状态只看**有定理**的函数
// 与被拒绝的函数——无定理函数没有义务,不该拖低整体(但它们
// 自己的行如实保留 unverified / tier none)。
{
let relevant = functions.iter().filter(|f| {
!f.claims.is_empty() || f.verdict == Verdict::Rejected
});
for f in relevant {
status = Verdict::worst(status, f.verdict);
}
}
let report = Report {
file: file_display,
source_sha256,
artifact_id: artifact_dir
.as_ref()
.map(|d| d.file_name().map(|n| n.to_string_lossy().to_string()))
.unwrap_or(None),
status,
functions,
diagnostics,
emitted,
lean: lean_info,
duration_ms: started.elapsed().as_millis(),
};
// Knowledge linkage is advisory. Failing to bind must not invent a proof
// or change the judgment of the underlying v2.8.0 prover.
#[cfg(feature = "cli")]
if let Some(dir) = artifact_dir.as_deref() {
if let Err(err) = crate::knowledge::proof::emit_links(path, &report, dir) {
eprintln!("warning[knowledge.proof_linkage]: {err:#}");
}
}
Ok(report)
}
/// 离线判定(§5):checked/反例贴回定理,绝不冒充 proved。
/// 单调性护栏在此埋点:离线结论会在 judge_with_lean 里被 Lean 复核。
fn judge_offline(
plan: &crate::prove::ir::Plan,
functions: &mut [FunctionReport],
diagnostics: &mut Vec<Diagnostic>,
) {
use crate::diagnostics::Span;
let debug = std::env::var("MARQDO_PROOF_DEBUG").is_ok_and(|v| v == "1");
for f in plan.functions.iter() {
for claim in &f.claims {
let verdict = offline::check_claim(f, claim);
if debug {
eprintln!(
"[offline] {}.{} → {:?}",
f.name, claim.id, verdict
);
}
let Some(fr) = functions.iter_mut().find(|x| x.name == f.name) else {
continue;
};
let Some(cr) = fr.claims.iter_mut().find(|c| c.id == claim.id) else {
continue;
};
match verdict {
offline::OfflineVerdict::Checked { cases } => {
cr.status = Verdict::Checked;
cr.decided_by = "trace".into();
cr.evidence = Some(format!("离线符号执行:{cases} 条路径全部关闭(F1–F5)"));
cr.source_line = Some(claim.line);
fr.tier = Tier::Offline;
}
offline::OfflineVerdict::Unproved { counterexample } => {
cr.status = Verdict::Unproved;
cr.decided_by = "trace".into();
cr.source_line = Some(claim.line);
cr.evidence = counterexample.as_ref().map(|c| {
format!(
"反例(离线符号执行):{} — 路径 #{}",
c.detail, c.path_id
)
});
if let Some(c) = &counterexample {
diagnostics.push(
Diagnostic::new(
None,
Span::new(claim.line, 0),
format!(
"定理 {}.{} 反例:{}",
f.name, claim.id, c.detail
),
)
.with_code("proof.claim_failed"),
);
}
fr.tier = Tier::Offline;
}
offline::OfflineVerdict::Unverified { reason } => {
// 不猜:保留 unverified(不写 evidence,让位给 Lean 结果)。
let _ = reason;
}
}
fr.verdict = fr
.claims
.iter()
.map(|x| x.status)
.fold(Verdict::Proved, Verdict::worst);
}
}
}
/// 单一判定来源:缓存证书 → Lean 现算。返回(整体判定,lean 信息)。
#[allow(clippy::too_many_arguments)]
fn judge_with_lean(
plan: &crate::prove::ir::Plan,
source_sha256: &str,
artifact_dir: Option<&Path>,
generated_lean: &Option<(PathBuf, String)>,
opts: &ProveOptions,
functions: &mut [FunctionReport],
diagnostics: &mut Vec<Diagnostic>,
) -> Result<(Option<Verdict>, Option<LeanInfo>)> {
use crate::diagnostics::Span;
let Some((lean_path, lean_src)) = generated_lean else {
return Ok((None, None));
};
// 缓存键素材:工具链版本先探测(没有工具链就谈不上判定)。
let toolchain = match driver::Toolchain::discover(opts.lean.as_deref()) {
Ok(t) => t,
Err(err) => {
if opts.require_lean {
return Err(err);
}
diagnostics.push(
Diagnostic::new(None, Span::new(0, 0), format!("{err:#}"))
.with_code("proof.lean_missing"),
);
return Ok((None, None));
}
};
let Some(toolchain) = toolchain else {
// 没找到工具链:保持 unverified(诚实:没跑就是没跑)。
// --require-lean 时退出码由 Verdict::exit_code 升到 2(§3.3 F3)。
if opts.require_lean {
diagnostics.push(
Diagnostic::new(
None,
Span::new(0, 0),
"--require-lean:未找到 Lean 工具链(PATH/MARQDO_PROOF_LEAN/--lean)",
)
.with_code("proof.lean_missing"),
);
}
return Ok((None, None));
};
// 库(内嵌源 → olean,按内容哈希缓存)。
let cache_root = Path::new(".marqdo/prove");
let (lib_dir, library_sha256) = driver::ensure_library(cache_root, &toolchain)?;
let module_sha256 = cache::sha256_hex(lean_src.as_bytes());
let plan_sha = cache::sha256_hex(plan.to_stable_json().as_bytes());
let key = cache::cache_key(
source_sha256,
&plan_sha,
&library_sha256,
&toolchain.version,
env!("CARGO_PKG_VERSION"),
);
let mut artifact_fallback: Option<PathBuf> = None;
let artifact: &Path = match artifact_dir {
Some(d) => d,
None => {
let d = default_emit_dir(source_sha256);
// 极少见:report-only 之外无产物目录(理论上不可达)——现建。
let _ = std::fs::create_dir_all(&d);
// 借用问题:把目录放成一个本地 owned 值,再取引用。
artifact_fallback.get_or_insert(d).as_path()
}
};
// ① 证书命中 → 跳过判定。
if !opts.no_cache {
if let Some(cert) = cache::load(artifact, &key) {
apply_claims(functions, &cert.claims, &cert.span_map, diagnostics);
let status = cert.status;
return Ok((
Some(status),
Some(LeanInfo {
toolchain: toolchain.version,
library_sha256,
module_sha256,
cache: "hit",
}),
));
}
}
// ② 现算:lean 直接调用(LEAN_PATH 指向底座 olean)。
let mut outcome = driver::check_module(
&toolchain,
&lib_dir,
lean_path,
lean_src,
opts.timeout,
opts.max_heartbeats,
)?;
// 测试注入(roadmap P2 单调性护栏):让首条定理在 Lean 侧"关不掉",
// 验证离线 checked + Lean unproved ⇒ error[proof.divergence] 的护栏真的咬人。
if std::env::var("MARQDO_PROOF_INJECT_DIVERGENCE").is_ok_and(|v| v == "1") {
if let Some(first) = outcome.claims.iter_mut().find(|c| c.status == Verdict::Proved) {
first.status = Verdict::Unproved;
first.detail = "injected divergence (MARQDO_PROOF_INJECT_DIVERGENCE)".into();
}
}
// ③ 证据 → 诊断(proof.claim_failed,指回源码行)。
let claim_records: Vec<cache::ClaimRecord> = outcome
.claims
.iter()
.map(|c| cache::ClaimRecord {
id: c.claim.clone(),
function: c.function.clone(),
status: c.status,
source_line: c.source_line,
})
.collect();
apply_outcome(functions, &outcome.claims, diagnostics);
let cert = cache::Certificate {
key: key.clone(),
status: outcome.status,
tier: "lean",
source_sha256: source_sha256.to_string(),
library_sha256: library_sha256.clone(),
toolchain: toolchain.version.clone(),
module_sha256: module_sha256.clone(),
claims: claim_records,
span_map: outcome.span_map.clone(),
marqdo: env!("CARGO_PKG_VERSION").to_string(),
};
if let Err(err) = cache::store(artifact, &cert) {
diagnostics.push(
Diagnostic::new(
None,
Span::new(0, 0),
format!("证书写入失败(不阻塞判定):{err:#}"),
)
.with_code("proof.cache_write"),
);
}
Ok((
Some(outcome.status),
Some(LeanInfo {
toolchain: toolchain.version,
library_sha256,
module_sha256,
cache: "miss",
}),
))
}
/// 把判定结果按 (函数, 定理 id) 贴回函数报告。
fn apply_outcome(
functions: &mut [FunctionReport],
claims: &[driver::ClaimOutcome],
diagnostics: &mut Vec<Diagnostic>,
) {
use crate::diagnostics::Span;
for c in claims {
let matches_fn = |f: &FunctionReport| {
f.name == c.function
|| emit::lean_ident(&f.name)
.trim_matches('«')
.trim_matches('»')
== c.function
};
let Some(pos) = functions.iter().position(matches_fn) else {
continue;
};
let f = &mut functions[pos];
if let Some(claim) = f.claims.iter_mut().find(|x| x.id == c.claim) {
// 单调性护栏(§5.4):离线结论必须被 Lean 复核印证。
// checked 但 Lean 关不掉,或离线反例被 Lean 证出来 ⇒ 判定器有 bug。
let divergence = match (claim.status, c.status) {
(Verdict::Checked, Verdict::Unproved)
| (Verdict::Unproved, Verdict::Proved) => true,
_ => false,
};
if divergence {
diagnostics.push(
Diagnostic::new(
None,
Span::new(claim.source_line.unwrap_or(0), 0),
format!(
"离线与 Lean 判定分歧:定理 {}.{} 离线 {:?},Lean {}——判定器缺陷,拒绝落绿",
f.name, c.claim, claim.status, c.status.as_str()
),
)
.with_code("proof.divergence"),
);
claim.status = Verdict::Error;
claim.decided_by = "lean".into();
f.verdict = Verdict::Error;
f.tier = Tier::Lean;
continue;
}
claim.status = c.status;
claim.decided_by = "lean".into();
claim.source_line = c.source_line;
claim.evidence = (!c.detail.is_empty()).then(|| c.detail.clone());
if c.status == Verdict::Unproved {
diagnostics.push(
Diagnostic::new(
None,
Span::new(c.source_line.unwrap_or(0), 0),
format!(
"定理 {}.{} 未证:{}",
c.function,
c.claim,
first_line(&c.detail)
),
)
.with_code("proof.claim_failed"),
);
}
f.verdict = f
.claims
.iter()
.map(|x| x.status)
.fold(Verdict::Proved, Verdict::worst);
f.tier = Tier::Lean;
}
}
}
/// 证书命中的同款贴回。
fn apply_claims(
functions: &mut [FunctionReport],
claims: &[cache::ClaimRecord],
span_map: &[(u32, u32)],
diagnostics: &mut Vec<Diagnostic>,
) {
use crate::diagnostics::Span;
for c in claims {
let source_line = c.source_line.or_else(|| {
span_map
.first()
.map(|(_, m)| *m)
});
if let Some(f) = functions
.iter_mut()
.find(|f| f.name == c.function)
{
if let Some(claim) = f.claims.iter_mut().find(|x| x.id == c.id) {
claim.status = c.status;
claim.decided_by = "lean".into();
claim.source_line = source_line;
if c.status == Verdict::Unproved {
diagnostics.push(
Diagnostic::new(
None,
Span::new(source_line.unwrap_or(0), 0),
format!("定理 {}.{} 未证(缓存)", f.name, c.id),
)
.with_code("proof.claim_failed"),
);
}
f.verdict = f
.claims
.iter()
.map(|x| x.status)
.fold(Verdict::Proved, Verdict::worst);
f.tier = Tier::Lean;
}
}
}
}
fn summarize(lowered: &[Lowered], only: &[String]) -> Vec<FunctionReport> {
lowered
.iter()
.filter(|l| !l.is_object)
.filter(|l| only.is_empty() || only.iter().any(|name| name == &l.display))
.map(|l| {
let (verdict, tier, ops, rejected, claims) = match &l.plan {
Some(plan) => (
Verdict::Unverified,
Tier::None,
plan.ops
.iter()
.map(|op| (op.id.clone(), op.effect.clone()))
.collect(),
Vec::new(),
plan.claims
.iter()
.map(|c| ClaimReport {
id: c.id.clone(),
premise: c.premise.clone(),
conclusion: c.conclusion.clone(),
tactic: c.tactic.clone(),
status: Verdict::Unverified,
decided_by: String::new(),
source_line: None,
evidence: None,
})
.collect(),
),
None => (
Verdict::Rejected,
Tier::None,
Vec::new(),
l.rejected
.iter()
.map(|d| {
(
d.code.clone(),
d.message.clone(),
d.span.line,
)
})
.collect(),
Vec::new(),
),
};
FunctionReport {
name: l.display.clone(),
verdict,
tier,
ops,
rejected,
claims,
}
})
.collect()
}
/// 默认产物目录:`.marqdo/prove/<key8>/`(key = 源 sha256 前 8 位)。
pub fn default_emit_dir(source_sha256: &str) -> PathBuf {
PathBuf::from(".marqdo/prove").join(&source_sha256[..source_sha256.len().min(8)])
}
/// `prove clean`:删除 `.marqdo/prove`(--emit 指定目录不动)。
pub fn clean() -> Result<usize> {
let root = Path::new(".marqdo/prove");
if !root.exists() {
return Ok(0);
}
let count = std::fs::read_dir(root)?.count();
std::fs::remove_dir_all(root)
.with_context(|| format!("删除 {}", root.display()))?;
Ok(count)
}
fn display_path(path: &Path) -> String {
let cwd = std::env::current_dir().unwrap_or_default();
path.strip_prefix(&cwd)
.unwrap_or(path)
.to_string_lossy()
.to_string()
}
fn relative_cwd(path: &Path) -> PathBuf {
let cwd = std::env::current_dir().unwrap_or_default();
path.strip_prefix(&cwd).unwrap_or(path).to_path_buf()
}