pub enum CertificateArtifact<'a> {
WasmGc {
file_name: &'a str,
module_bytes: &'a [u8],
},
Wasip2 {
file_name: &'a str,
component_bytes: &'a [u8],
embedded_core_module: &'a [u8],
envelope: crate::format::Wasip2ComponentEnvelopeDeclaration,
},
}
impl CertificateArtifact<'_> {
fn validate(&self) -> Result<(), String> {
match self {
Self::WasmGc { module_bytes, .. } => {
if module_bytes.is_empty() {
return Err("cannot certify an empty wasm-gc module".to_string());
}
}
Self::Wasip2 {
component_bytes,
embedded_core_module,
envelope,
..
} => {
let (_, declared_core, _) = envelope.split_component(component_bytes).ok_or_else(|| {
"wasip2 certificate envelope does not split the delivered component by its declared lengths"
.to_string()
})?;
if declared_core != *embedded_core_module {
return Err(
"wasip2 certificate core bytes do not equal the envelope-declared component slice"
.to_string(),
);
}
}
}
Ok(())
}
pub fn file_name(&self) -> &str {
match self {
Self::WasmGc { file_name, .. } | Self::Wasip2 { file_name, .. } => file_name,
}
}
fn delivered_bytes(&self) -> &[u8] {
match self {
Self::WasmGc { module_bytes, .. } => module_bytes,
Self::Wasip2 {
component_bytes, ..
} => component_bytes,
}
}
pub fn core_module_bytes(&self) -> &[u8] {
match self {
Self::WasmGc { module_bytes, .. } => module_bytes,
Self::Wasip2 {
embedded_core_module,
..
} => embedded_core_module,
}
}
pub fn target(&self) -> &'static str {
match self {
Self::WasmGc { .. } => crate::format::TARGET_WASM_GC,
Self::Wasip2 { .. } => crate::format::TARGET_WASIP2,
}
}
fn abi(&self) -> &'static str {
match self {
Self::WasmGc { .. } => crate::format::RUNTIME_ABI_WASM_GC,
Self::Wasip2 { .. } => crate::format::RUNTIME_ABI_WASIP2,
}
}
fn wasip2_component_envelope(
&self,
) -> Option<crate::format::Wasip2ComponentEnvelopeDeclaration> {
match self {
Self::WasmGc { .. } => None,
Self::Wasip2 { envelope, .. } => Some(*envelope),
}
}
}
#[derive(Debug, Default)]
pub struct ProjectDeclines {
pub law_claims: Vec<(String, String)>,
pub source_bridges: Vec<(String, String)>,
}
fn lean_str(s: &str) -> String {
let mut out = String::with_capacity(s.len() + 2);
out.push('"');
for ch in s.chars() {
match ch {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
_ => out.push(ch),
}
}
out.push('"');
out
}
fn json_str(s: &str) -> String {
let mut out = String::with_capacity(s.len() + 2);
out.push('"');
for ch in s.chars() {
match ch {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
_ => out.push(ch),
}
}
out.push('"');
out
}
fn write(dir: &Path, name: &str, content: &str) -> Result<(), String> {
let path = dir.join(name);
std::fs::write(&path, content).map_err(|e| format!("write {}: {e}", path.display()))
}
fn lean_char_list(s: &str) -> String {
let chars = s
.chars()
.map(|c| {
if (' '..='~').contains(&c) && !matches!(c, '\'' | '\\' | '"') {
format!("'{c}'")
} else {
format!("(Char.ofNat {})", c as u32)
}
})
.collect::<Vec<_>>()
.join(", ");
format!("[{chars}]")
}
fn lean_char_lists(items: &[String], separator: &str) -> String {
let lists = items
.iter()
.map(|item| lean_char_list(item))
.collect::<Vec<_>>()
.join(&format!(",{separator}"));
format!("[{lists}]")
}
fn lean_char_pairs(items: &[(String, String)]) -> String {
let pairs = items
.iter()
.map(|(a, b)| format!("({}, {})", lean_char_list(a), lean_char_list(b)))
.collect::<Vec<_>>()
.join(",\n ");
format!("[{pairs}]")
}
fn plan_def_name(func_idx: u32) -> String {
format!("fn{func_idx}")
}
fn render_plans(analysis: &Analysis) -> String {
let mut s = String::from(
"-- The certificate's plans: every planned function's optimized MIR body,\n\
-- printed 1:1 into the one plan grammar, and the declared type layout.\n\
-- Producer data: the wall lowers each plan and pins the result to the\n\
-- function's code entry, and confirms the layout against the bytes.\n\
import SchemaCore\n\n\
namespace AverCert.Plans\n\
open AverCert.Schema AverCert.Grammar\n\n",
);
s.push_str(&analysis.types.lean_decls("types"));
for e in &analysis.entries {
s.push_str(&format!(
"/-- `{}` (function {}). -/\ndef {} : FnPlan :=\n {}\n\n",
e.name.replace('-', "_"),
e.func_idx,
plan_def_name(e.func_idx),
e.plan.lean()
));
}
let entries = analysis
.entries
.iter()
.map(|e| {
format!(
"⟨{}, {}, {}, {}, {}⟩",
lean_str(&e.name),
e.exported,
e.func_idx,
e.group,
plan_def_name(e.func_idx)
)
})
.collect::<Vec<_>>();
let depth = if entries.len() > 512 {
"set_option maxRecDepth 100000 in\n"
} else {
""
};
let entries = format!("[{}]", entries.join(",\n "));
s.push_str(&format!("{depth}def fnPlans : List FnEntry :=\n {entries}\n\n"));
s.push_str("end AverCert.Plans\n");
s
}
fn declared_uncertified(analysis: &Analysis) -> Vec<(String, String)> {
let mut declared = analysis
.module_envelope
.declared_uncertified(analysis.certified_names(), &analysis.declined);
declared.sort_by_cached_key(|(name, _)| name_key_order(name));
declared
}
fn name_key_order(name: &str) -> (usize, Vec<u32>) {
let mut codes: Vec<u32> = name.chars().map(u32::from).collect();
codes.reverse();
(codes.len(), codes)
}
fn render_manifest_lean(
analysis: &Analysis,
sha: &str,
target: &str,
abi: &str,
declared_pieces: Option<&[Vec<(String, String)>]>,
) -> String {
let roles = match &analysis.roles {
Some(r) => format!("some {}", r.roles_lean_value()),
None => "(none : Option CertDecode.AddSub.Roles)".to_string(),
};
let params = match analysis
.roles
.as_ref()
.and_then(|r| r.arith_params_record_lean(analysis.carrier))
{
Some(p) => format!("some {p}"),
None => "(none : Option ArithTemplateDerisk.ArithHostParams)".to_string(),
};
let strings = format!(
"[{}]",
analysis
.string_roles
.iter()
.map(|(idx, role)| format!("({idx}, {})", role.lean_value()))
.collect::<Vec<_>>()
.join(", ")
);
let start = match analysis.module_envelope.start {
Some(i) => format!("some {i}"),
None => "none".to_string(),
};
let mut pieces = String::new();
let string_items = |items: &[String]| items.iter().map(|x| lean_str(x)).collect::<Vec<_>>();
let pair_items = |items: &[(String, String)]| {
items
.iter()
.map(|(a, b)| format!("({}, {})", lean_str(a), lean_str(b)))
.collect::<Vec<_>>()
};
let exports = lean_list_in_pieces(
&mut pieces,
"Plans.subject_exports",
"String",
&string_items(&analysis.certified_names()),
);
let declared = match declared_pieces {
None => lean_list_in_pieces(
&mut pieces,
"Plans.subject_declaredUncertified",
"String × String",
&pair_items(&declared_uncertified(analysis)),
),
Some(blocks) => {
let mut names = Vec::new();
for (b, piece) in blocks.iter().enumerate() {
let name = format!("Plans.subject_declaredUncertified_{b}");
pieces.push_str(&format!(
"def {name} : List (String × String) :=\n [{}]\n\n",
pair_items(piece).join(",\n ")
));
names.push(name);
}
right_nested(&names)
}
};
let capabilities = lean_list_in_pieces(
&mut pieces,
"Plans.subject_capabilities",
"String × String",
&pair_items(&analysis.module_envelope.capabilities),
);
let contracts = lean_list_in_pieces(
&mut pieces,
"Plans.subject_contracts",
"String",
&string_items(&analysis.contracts),
);
format!(
"-- The certificate's manifest: the subject (artifact identity, exports,\n\
-- helper indices and the contracts it is conditional on), the plans and\n\
-- the obligations, which are exactly the ones the wall derives.\n\
import SchemaCore\n\
import AcceptedArtifactCore\n\
import Plans\n\n\
namespace AverCert\n\
open AverCert.Schema\n\n\
{pieces}\
def subject : Subject :=\n \
{{ artifactHash := {sha}\n \
target := {target}, profile := {profile}, abi := {abi}\n \
artifactRoot := {root}\n \
exports := {exports}\n \
declaredUncertified := {declared}\n \
capabilities := {capabilities}\n \
start := {start}\n \
hostRoleTable := {roles}\n \
arithParams := {params}\n \
stringHostRoles := {strings}\n \
contracts := {contracts} }}\n\n\
def manifest : Manifest :=\n \
{{ subject := subject, types := Plans.types, fnPlans := Plans.fnPlans,\n \
obligations := AverCert.AcceptedArtifact.obligationsOf subject Plans.types Plans.fnPlans }}\n\n\
end AverCert\n",
sha = lean_str(sha),
target = lean_str(target),
profile = lean_str(PROFILE_ID),
abi = lean_str(abi),
root = lean_str(ARTIFACT_CERTIFICATE_ROOT),
)
}
fn render_artifact_host_roles(analysis: &Analysis, params: &str, layout: bool) -> String {
let roles = analysis.roles.expect("a carriered module declares roles");
let proof = if layout {
"by\n rw [AverCert.DeclaredLayout.arithRoleCheck_of_layout layout_ok] <;> decide +kernel"
} else {
"by decide +kernel"
};
let leaf = |name: &str, idx: Option<u32>| {
let idx = idx.map_or_else(|| "none".to_string(), |idx| format!("(some {idx})"));
format!(
"theorem decodedHostRole_{name} : AverCert.AcceptedArtifact.arithRoleCheck \
AverCert.ArtifactBytes.modBytes AverCert.ArtifactBytes.modLen \
ArithTemplateDerisk.ArithRole.{name} {idx} {params} = true := {proof}"
)
};
let leaves = [
leaf("box", roles.box_idx),
leaf("toIndex", roles.to_index_idx),
leaf("add", roles.add_idx),
leaf("sub", roles.sub_idx),
leaf("mul", roles.mul_idx),
leaf("cmp", roles.cmp_idx),
leaf("eq", roles.eq_idx),
leaf("divmod", roles.divmod_idx),
]
.join("\n\n");
format!(
"-- Per-role helper template pins, each in its own `decide +kernel`\n\
-- declaration, in a separate compilation unit.\n\
import AcceptedArtifact\n\
import ArtifactBytes\n\
{layout_import}\n\
set_option maxRecDepth 200000\n\n\
namespace AverCert.Artifact\n\n\
{leaves}\n\n\
end AverCert.Artifact\n",
layout_import = if layout {
format!("import {}\n", layout_facts_module(analysis))
} else {
String::new()
},
)
}
const PLAN_CHUNK: usize = 32;
const PLANS_PER_MODULE: usize = 100;
fn render_artifact_plans(
analysis: &Analysis,
decls: &[String],
sites: &[String],
layout: bool,
) -> Vec<(String, String)> {
let n = analysis.entries.len();
let header = "set_option maxRecDepth 200000\n\
set_option maxHeartbeats 1600000\n\n\
namespace AverCert.Artifact\n\
open AverCert AverCert.Schema AverCert.AcceptedArtifact AverCert.TypeTable\n\n";
let plan_ok = "/-- One plan's acceptance check against the staged artifact bytes. -/\n\
noncomputable abbrev planOk : FnEntry → Bool :=\n \
entryAccepted AverCert.ArtifactBytes.modBytes AverCert.ArtifactBytes.modLen\n \
(mctxOf AverCert.manifest.subject AverCert.manifest.types AverCert.manifest.fnPlans)\n \
AverCert.manifest.fnPlans\n\n";
if !layout {
return vec![(
"ArtifactPlans.lean".to_string(),
format!(
"-- The per-plan acceptance checks.\n\
import AcceptedArtifact\nimport ArtifactBytes\nimport Manifest\n\n\
{header}{plan_ok}\
theorem plans_all : AverCert.manifest.fnPlans.all planOk = true := by\n \
decide +kernel\n\n\
end AverCert.Artifact\n"
),
)];
}
let split = splits_artifact_modules(analysis);
let check = format!(
"{plan_ok}\
/-- The lowering context of every plan check. -/\n\
abbrev planM : AverCert.Grammar.MCtx :=\n \
mctxOf AverCert.manifest.subject AverCert.manifest.types AverCert.manifest.fnPlans\n\n\
/-- One plan entry's check (`ScaleLayout.planOne`). -/\n\
noncomputable abbrev planCheck :\n \
FnEntry → AverCert.DeclaredLayout.FnDecl → Nat → Nat × Nat → Bool :=\n \
AverCert.ScaleLayout.planOne AverCert.ArtifactBytes.chunks layout fnTypes planM\n \
AverCert.manifest.fnPlans exportStart exportStarts\n\n\
/-- The plan checks along the lists (`ScaleLayout.plansFrom`). -/\n\
noncomputable abbrev plansOf : List FnEntry → List AverCert.DeclaredLayout.FnDecl →\n \
List Nat → List (Nat × Nat) → Bool :=\n \
AverCert.ScaleLayout.plansFrom AverCert.ArtifactBytes.chunks layout fnTypes planM\n \
AverCert.manifest.fnPlans exportStart exportStarts\n\n\
theorem types_ok : AverCert.DeclaredLayout.fnTypesConfirmed AverCert.ArtifactBytes.modBytes\n \
AverCert.ArtifactBytes.modLen fnTypes = true := by\n \
rw [AverCert.DeclaredLayout.fnTypesConfirmed, types_at]; decide +kernel\n\n"
);
let names = "theorem names_eq : AverCert.manifest.fnPlans.map (·.name) =\n \
fnDecls.map (fun d => String.ofList d.name) := rfl\n\n";
let plan = |i: usize| {
let e = &analysis.entries[i];
format!(
"theorem plan_{i} : planCheck\n ⟨{}, {}, {}, {}, AverCert.Plans.{}⟩\n {}\n {} {} = true := by\n \
decide +kernel\n\n",
lean_str(&e.name),
e.exported,
e.func_idx,
e.group,
plan_def_name(e.func_idx),
decls[i],
analysis.role_bits[i],
sites[i]
)
};
let block = |k: usize, m: usize| {
let mut term = "AverCert.ScaleLayout.plansFrom_nil _ _ _ _ _ _ _".to_string();
for i in (k..k + m).rev() {
term = format!("AverCert.ScaleLayout.plansFrom_cons plan_{i}\n ({term})");
}
format!(
"theorem plans_block_{k} : plansOf ((AverCert.manifest.fnPlans.drop {k}).take {m})\n \
((fnDecls.drop {k}).take {m}) ((callBits.drop {k}).take {m})\n \
((exportSites.drop {k}).take {m}) = true :=\n \
{term}\n\n"
)
};
let per_module = if split { PLANS_PER_MODULE } else { n.max(1) };
let starts: Vec<usize> = (0..n).step_by(per_module).collect();
let mut joined = format!(
"(AverCert.ScaleLayout.plansFrom_nil _ _ _ _ _ _ _ :\n \
plansOf (AverCert.manifest.fnPlans.drop {n}) (fnDecls.drop {n}) (callBits.drop {n})\n \
(exportSites.drop {n}) = true)"
);
for &k in starts.iter().rev() {
let m = per_module.min(n - k);
joined = format!(
"AverCert.ScaleLayout.plansFrom_block (k := {k}) (m := {m}) plans_block_{k}\n ({joined})"
);
}
let end = format!(
"theorem plans_packed : plansOf AverCert.manifest.fnPlans fnDecls callBits exportSites = true :=\n \
{joined}\n\n\
theorem plans_checked : AverCert.manifest.fnPlans.all planOk = true ∧\n \
AverCert.manifest.fnPlans.map (AverCert.ScaleLayout.roleBits planM) = callBits :=\n \
AverCert.ScaleLayout.entries_of_packed bytes_eq chunks_fit layout_ok types_ok export_names_ok\n \
names_eq exports_cut_ok exports_head export_starts plans_packed\n\n\
/-- The export accounting: the export walk, and every planned export read at\n\
its site by its plan's check. -/\n\
theorem exports_accounted : AverCert.AcceptedArtifact.exportsAccountedOf\n \
AverCert.ArtifactBytes.modBytes AverCert.ArtifactBytes.modLen\n \
(AverCert.AcceptedArtifact.certifiedExportEntries AverCert.manifest)\n \
(AverCert.AcceptedArtifact.declaredUncertifiedNames AverCert.manifest) = true :=\n \
AverCert.ScaleExports.exportsAccounted_of_walk bytes_eq chunks_fit exports_head export_starts\n \
exports_walk plans_packed names_eq cert_bits rfl\n\n\
theorem plans_all : AverCert.manifest.fnPlans.all planOk = true := plans_checked.1\n\n\
theorem plans_roles : AverCert.manifest.fnPlans.map (AverCert.ScaleLayout.roleBits planM) =\n \
callBits := plans_checked.2\n\n\
end AverCert.Artifact\n"
);
let imports = format!(
"import AcceptedArtifact\nimport ArtifactBytes\nimport Manifest\nimport {}\n{}\n",
layout_facts_module(analysis),
if split { "" } else { "import ArtifactExports\n" }
);
let module_body = |k: usize| {
let m = per_module.min(n - k);
let mut body: String = (k..k + m).map(plan).collect();
body.push_str(&block(k, m));
body
};
if !split {
let body: String = starts.iter().map(|&k| module_body(k)).collect();
return vec![(
"ArtifactPlans.lean".to_string(),
format!(
"-- The per-plan acceptance checks, one declaration per plan, joined into\n\
-- the check over every plan.\n\
{imports}{header}{check}{names}{body}{end}"
),
)];
}
let mut files = vec![(
"ArtifactPlanCheck.lean".to_string(),
format!(
"-- The per-plan check the plan modules decide, and the facts every plan\n\
-- check shares.\n\
{imports}{header}{check}end AverCert.Artifact\n"
),
)];
files.push((
"ArtifactPlanNames.lean".to_string(),
format!(
"-- The plan entries' names, as the layout declares them.\n\
import Manifest\nimport ArtifactLayout\n\n\
{header}{names}end AverCert.Artifact\n"
),
));
let mut plan_imports = String::from("import ArtifactPlanNames\n");
for &k in &starts {
files.push((
format!("ArtifactPlans{k}.lean"),
format!(
"-- The per-plan checks of plans {k} to {}, one declaration each.\n\
import ArtifactPlanCheck\n\n\
{header}{}end AverCert.Artifact\n",
k + per_module.min(n - k) - 1,
module_body(k)
),
));
plan_imports.push_str(&format!("import ArtifactPlans{k}\n"));
}
files.push((
"ArtifactPlans.lean".to_string(),
format!(
"-- The per-plan checks of the plan modules, joined into the check over\n\
-- every plan.\n\
{plan_imports}import ArtifactExports\n\n{header}{end}"
),
));
files
}
fn splits_artifact_modules(analysis: &Analysis) -> bool {
analysis.entries.len() > PLAN_CHUNK
}
fn exports_fact_module(analysis: &Analysis) -> &'static str {
if splits_artifact_modules(analysis) {
"ArtifactInterface"
} else {
"Artifact"
}
}
const ARTIFACT_HEADER: &str = "set_option maxRecDepth 200000\n\
-- Elaboration cost grows with the artifact; this moves a resource\n\
-- limit only (no axiom, no hypothesis, nothing the kernel accepts).\n\
set_option maxHeartbeats 1600000\n\n\
namespace AverCert.Artifact\n\
open AverCert AverCert.Schema AverCert.AcceptedArtifact\n\n";
fn render_artifact(
analysis: &Analysis,
envelope: Option<crate::format::Wasip2ComponentEnvelopeDeclaration>,
string_blocks: Option<&str>,
data_blocks: Option<&str>,
helper_sites: &[(&str, usize, usize)],
) -> Vec<(String, String)> {
let layout = string_blocks.is_some();
let envelope = match envelope {
None => "none".to_string(),
Some(env) => format!(
"some {{ prefixLen := {}, embeddedCoreModuleLen := {}, suffixLen := {} }}",
env.prefix_len, env.embedded_core_module_len, env.suffix_len
),
};
let closure = &analysis.module_envelope.closure;
let nats = |xs: &[u32]| {
format!(
"[{}]",
xs.iter().map(u32::to_string).collect::<Vec<_>>().join(", ")
)
};
let (roles_import, roles_proof) = match (
&analysis.roles,
analysis
.roles
.as_ref()
.and_then(|r| r.arith_params_record_lean(analysis.carrier)),
) {
(Some(r), Some(params)) => {
let site = |name: &str| helper_sites.iter().find(|(n, _, _)| *n == name);
let site_fact = |thm: &str, stmt: String, name: &str, lemma: &str| {
let (_, off, l) = site(name)?;
Some(format!(
"theorem {thm} : {stmt} :=\n \
{lemma}\n \
(AverCert.ScaleTables.helperIdx_of_site bytes_eq chunks_fit exports_head exports_cut_ok\n \
export_starts export_names_ok (off := {off}) (l := {l}) (by decide +kernel))\n\n"
))
};
const B: &str = "AverCert.ArtifactBytes.modBytes AverCert.ArtifactBytes.modLen";
let mut facts = String::new();
let mut lemmas: Vec<String> = Vec::new();
let mut by_name = |thm: &str, fun: &str, eq: &str, name: &str, idx: Option<u32>| {
let fact = if layout {
idx.and_then(|fi| {
site_fact(
thm,
format!("CertDecode.AddSub.{fun} {B} = some {fi}"),
name,
&format!("(AverCert.DeclaredLayout.Chars.{eq} _ _).trans"),
)
})
} else {
None
};
match fact {
Some(text) => {
facts.push_str(&text);
lemmas.push(thm.to_string());
}
None => lemmas.push(format!("AverCert.DeclaredLayout.Chars.{eq}")),
}
};
by_name("helper_box", "boxIdx", "boxIdx_eq", "__rt_aint_from_i64", r.box_idx);
by_name("helper_to_index", "toIndexIdx", "toIndexIdx_eq", "__aint_to_index", r.to_index_idx);
by_name("helper_cmp", "cmpIdx", "cmpIdx_eq", "__aint_cmp", r.cmp_idx);
match (layout, r.box_idx, site("__rt_aint_from_i64")) {
(true, Some(fi), Some((_, off, l))) => {
facts.push_str(&format!(
"theorem helper_present : CertDecode.AddSub.carrierHelperAbsent {B} = false :=\n \
AverCert.ScaleTables.carrierHelperAbsent_of_site bytes_eq chunks_fit exports_head\n \
exports_cut_ok export_starts export_names_ok (off := {off}) (l := {l}) (fi := {fi})\n \
(by decide +kernel)\n\n"
));
lemmas.push("helper_present".to_string());
}
_ => lemmas.push("AverCert.DeclaredLayout.Chars.carrierHelperAbsent_eq".to_string()),
}
(
"import ArtifactHostRoles\n".to_string(),
format!(
"{facts}theorem roles_ok : decodedHostRoleTable data := by\n \
dsimp only [decodedHostRoleTable, data]\n \
rw [show AverCert.manifest.subject.hostRoleTable = some {} from rfl,\n \
show AverCert.manifest.subject.arithParams = some {params} from rfl]\n \
simp only [arithTableCheck, decodedHostRole_box, decodedHostRole_toIndex, \
decodedHostRole_add, decodedHostRole_sub, decodedHostRole_mul, decodedHostRole_cmp, \
decodedHostRole_eq, decodedHostRole_divmod, Bool.and_true, Bool.true_and,\n \
{}{cuts}]\n \
{carrier}decide +kernel",
r.roles_lean_value(),
lemmas.join(", "),
cuts = if layout { ", exports_cut" } else { "" },
carrier = if layout {
"simp -iota only [CertDecode.carrierState.eq_def, types_at]\n "
} else {
""
},
),
)
}
_ => (
String::new(),
"theorem roles_ok : decodedHostRoleTable data := by\n \
unfold decodedHostRoleTable; decide +kernel"
.to_string(),
),
};
let data = format!(
"noncomputable def data : ArtifactData :=\n \
{{ modBytes := AverCert.ArtifactBytes.modBytes, modLen := AverCert.ArtifactBytes.modLen,\n \
manifest := AverCert.manifest, wasip2ComponentEnvelope := {envelope},\n \
closureFuel := {fuel},\n \
closureClaim := ⟨{roots}, {helpers}, {admitted}⟩ }}\n\n",
fuel = analysis.module_envelope.closure_fuel,
roots = nats(&closure.roots),
helpers = nats(&closure.helpers),
admitted = nats(&closure.admitted),
);
let strings = match string_blocks {
Some(blocks) => blocks.to_string(),
None => "theorem strings_ok : decodedStringHostRoles data := by\n \
unfold decodedStringHostRoles\n \
rw [← AverCert.DeclaredLayout.StringFast.roleTableFast_eq]; decide +kernel\n\n"
.to_string(),
};
let split = splits_artifact_modules(analysis);
let (closure_blocks, closure_files) = if layout {
render_closure_blocks(analysis, split)
} else {
(String::new(), Vec::new())
};
let closure_ok = if layout {
format!(
"{closure_blocks}theorem closure_ok : closureIsolation data = true :=\n \
AverCert.ScaleClosure.closureIsolation_of_callees bytes_eq chunks_fit layout_ok\n \
closure_callees (by decide +kernel)\n\n"
)
} else {
"theorem closure_ok : closureIsolation data = true := by decide +kernel\n\n".to_string()
};
let closure_ok = closure_ok.as_str();
let layout_import = if layout {
format!(
"import {}\nimport SortedKeys\nimport ScaleTables\n",
layout_facts_module(analysis)
)
} else {
String::new()
};
let layout_import = layout_import.as_str();
let framing_proof = if layout {
"\n AverCert.ScaleLayout.moduleFramingValid_of_framing bytes_eq chunks_fit framing_decl"
} else {
" by\n decide +kernel"
};
let exports = format!(
"theorem framing_ok : CertDecode.moduleFramingValid data.modBytes data.modLen = true :={framing_proof}\n\n\
theorem exports_ok : exportsAccounted data = true :={exports_proof}\n\n\
theorem imports_ok : importsWithinCapabilities data = true :=\n \
AverCert.DeclaredLayout.Chars.importsWithinCapabilities_of_chars data\n \
{capabilities}\n \
rfl (by decide +kernel)\n\n\
theorem start_ok : startAccounted data = true := by decide +kernel\n\n",
exports_proof = if layout {
"\n exports_accounted".to_string()
} else {
format!(
"\n exportsAccounted_of_chars data\n {}\n {}\n rfl rfl (by decide +kernel)",
lean_char_lists(
&analysis
.entries
.iter()
.filter(|e| e.exported)
.map(|e| e.name.clone())
.collect::<Vec<_>>(),
"\n "
),
lean_char_lists(
&declared_uncertified(analysis)
.into_iter()
.map(|(name, _)| name)
.collect::<Vec<_>>(),
"\n "
),
)
},
capabilities = lean_char_pairs(&analysis.module_envelope.capabilities),
);
let rest_proof = if layout {
"(AverCert.DeclaredLayout.plansAcceptedRest_of_layout layout_ok\n \
(AverCert.DeclaredLayout.plansAcceptedRestL_of_parts rest_indices rest_types rest_data\n \
rest_roles rest_eqref rest_newtypes rest_inhabited rest_cons rest_helpers))"
} else {
"(by decide +kernel)"
};
let rest_parts = rest_parts(layout, data_blocks);
let (axes_blocks, axes_files) = if layout {
render_axes_blocks(analysis, split)
} else {
(String::new(), Vec::new())
};
let axes_proof = if layout {
"\n AverCert.ScaleLayout.checked_of_bits plans_roles\n \
(AverCert.ScaleTables.checkedBits_of_pols axes_pols (by decide +kernel))"
} else {
" by decide +kernel"
};
let rest = format!(
"theorem plans_ok : plansAccepted data = true :=\n \
plansAccepted_of_parts data plans_all {rest_proof}\n\n\
{roles_proof}\n\n\
{axes_blocks}\
theorem axes_ok : AverCert.ClaimAxes.checked data = true :={axes_proof}\n\n"
);
let tail = "theorem whole_ok : acceptedWholeModule data :=\n \
⟨framing_ok, exports_ok, imports_ok, start_ok, closure_ok⟩\n\n\
theorem envelope_ok : artifactEnvelopeAccepted AverCert.ArtifactComponentBytes.componentBytes\n \
AverCert.ArtifactComponentBytes.componentLen data = true := by decide +kernel\n\n\
end AverCert.Artifact\n";
let base_imports =
"import AcceptedArtifact\nimport DeclaredLayout\nimport ArtifactBytes\nimport Manifest\n";
if !splits_artifact_modules(analysis) {
let rest_all: String = rest_parts.iter().map(|(_, body)| body.as_str()).collect();
return vec![(
"Artifact.lean".to_string(),
format!(
"-- The artifact data and the byte facts of its acceptance, each by\n\
-- `decide +kernel` against the checker-staged `ArtifactBytes`.\n\
{base_imports}\
import ArtifactPlans\n\
{layout_import}\
{roles_import}\n\
{ARTIFACT_HEADER}\
{data}{rest_all}{rest}{strings}{exports}{closure_ok}{tail}"
),
)];
}
let part = |comment: &str, imports: &str, body: &str| {
format!(
"-- {comment}\n\
import ArtifactData\n\
{imports}\n\
{ARTIFACT_HEADER}\
{body}\
end AverCert.Artifact\n"
)
};
let mut rest_modules: Vec<(String, String)> = Vec::new();
for (module, body) in &rest_parts {
match rest_modules.iter_mut().find(|(name, _)| name == module) {
Some((_, text)) => text.push_str(body),
None => rest_modules.push((module.to_string(), body.clone())),
}
}
let axes_imports: String = axes_files
.iter()
.map(|(name, _)| format!("import {}\n", name.trim_end_matches(".lean")))
.collect();
let rest_imports: String = rest_modules
.iter()
.map(|(module, _)| format!("import {module}\n"))
.collect();
let mut files = vec![
(
"ArtifactData.lean".to_string(),
format!(
"-- The artifact data the byte facts speak about.\n\
{base_imports}\n\
{ARTIFACT_HEADER}\
{data}\
end AverCert.Artifact\n"
),
),
(
"ArtifactStrings.lean".to_string(),
part("The String helper roles, decoded from the module.", layout_import, &strings),
),
(
"ArtifactClosure.lean".to_string(),
part(
"The certified closure's isolation.",
&format!(
"{layout_import}{}",
closure_files
.iter()
.map(|(name, _)| format!("import {}\n", name.trim_end_matches(".lean")))
.collect::<String>()
),
closure_ok,
),
),
(
"ArtifactInterface.lean".to_string(),
part(
"The module's framing, exports, imports and start function.",
&format!("{layout_import}import ArtifactPlans\n"),
&exports,
),
),
(
"Artifact.lean".to_string(),
format!(
"-- The remaining byte facts of the artifact's acceptance, joined with\n\
-- the ones proved in the modules imported below.\n\
import ArtifactData\n\
import ArtifactStrings\n\
import ArtifactClosure\n\
import ArtifactInterface\n\
import ArtifactPlans\n\
{rest_imports}\
{axes_imports}\
{roles_import}\n\
{ARTIFACT_HEADER}\
{rest}{tail}"
),
),
];
files.extend(closure_files);
files.extend(axes_files);
for (module, body) in rest_modules {
files.push((
format!("{module}.lean"),
part(
"Conjuncts of the plans' acceptance other than the per-plan checks.",
&format!(
"import {}\nimport SortedKeys\nimport ScaleTables\n",
layout_facts_module(analysis)
),
&body,
),
));
}
files
}
const AXES_BLOCK: usize = 64;
const AXES_BLOCKS_PER_MODULE: usize = 4;
fn render_axes_blocks(analysis: &Analysis, split: bool) -> (String, Vec<(String, String)>) {
const OBL: &str = "AverCert.manifest.obligations";
const POL: &str = "AverCert.ScaleTables.polOf";
let pols: Vec<String> = analysis
.certified
.iter()
.map(|c| format!("({}, {})", c.total, c.total_mul))
.collect();
let blocks: Vec<&[String]> = pols.chunks(AXES_BLOCK).collect();
let last = blocks.len().saturating_sub(1);
let texts: Vec<String> = blocks
.iter()
.enumerate()
.map(|(b, block)| {
let k = b * AXES_BLOCK;
let lhs = if b == last {
format!("({OBL}.drop {k}).map {POL}")
} else {
format!("(({OBL}.drop {k}).take {AXES_BLOCK}).map {POL}")
};
format!(
"def axesPols_{b} : List (Bool × Bool) :=\n [{}]\n\n\
theorem pols_block_{b} : {lhs} = axesPols_{b} := by\n \
decide +kernel\n\n",
block.join(", ")
)
})
.collect();
let join = if blocks.is_empty() {
format!(
"def axesPols : List (Bool × Bool) := []\n\n\
theorem axes_pols : ({OBL}.drop 0).map {POL} = axesPols := by\n \
decide +kernel\n\n"
)
} else {
let names: Vec<String> = (0..blocks.len()).map(|b| format!("axesPols_{b}")).collect();
let mut proof = format!("pols_block_{last}");
for b in (0..last).rev() {
proof = format!("AverCert.ScaleTables.pols_cons pols_block_{b}\n ({proof})");
}
format!(
"-- Every obligation's policy answers: total, and total with the `mul`\n\
-- role, stated a block of obligations at a time.\n\
def axesPols : List (Bool × Bool) :=\n {}\n\n\
theorem axes_pols : ({OBL}.drop 0).map {POL} = axesPols :=\n {proof}\n\n",
right_nested(&names)
)
};
if !split {
return (format!("{}{join}", texts.concat()), Vec::new());
}
let files = texts
.chunks(AXES_BLOCKS_PER_MODULE)
.enumerate()
.map(|(m, chunk)| {
(
format!("ArtifactAxes{m}.lean"),
format!(
"-- Blocks of the obligations' policy answers (`Artifact.axes_pols`).\n\
import Manifest\n\
import ScaleTables\n\n\
set_option maxRecDepth 200000\n\n\
namespace AverCert.Artifact\n\n\
{}\
end AverCert.Artifact\n",
chunk.concat()
),
)
})
.collect();
(join, files)
}
const CLOSURE_BLOCK: usize = 64;
const CLOSURE_BLOCKS_PER_MODULE: usize = 4;
fn render_closure_blocks(analysis: &Analysis, split: bool) -> (String, Vec<(String, String)>) {
let scans = &analysis.module_envelope.closure_scans;
let blocks: Vec<&[(u32, Vec<u32>)]> = if scans.is_empty() {
vec![&[]]
} else {
scans.chunks(CLOSURE_BLOCK).collect()
};
let block_text = |b: usize, block: &[(u32, Vec<u32>)]| {
let items = block
.iter()
.map(|(func, callees)| {
format!(
"({func}, [{}])",
callees
.iter()
.map(u32::to_string)
.collect::<Vec<_>>()
.join(", ")
)
})
.collect::<Vec<_>>()
.join(",\n ");
format!(
"def closureCallees_{b} : List (Nat × List Nat) :=\n [{items}]\n\n\
theorem closure_block_{b} : AverCert.ScaleClosure.calleesOk AverCert.ArtifactBytes.chunks\n \
layout closureCallees_{b} = true := by\n \
decide +kernel\n\n"
)
};
let texts: Vec<String> = blocks
.iter()
.enumerate()
.map(|(b, block)| block_text(b, block))
.collect();
let names: Vec<String> = (0..blocks.len()).map(|b| format!("closureCallees_{b}")).collect();
let mut proof = format!("closure_block_{}", blocks.len() - 1);
for b in (0..blocks.len() - 1).rev() {
proof = format!("AverCert.ScaleClosure.calleesOk_append closure_block_{b}\n ({proof})");
}
let join = format!(
"-- Every function the closure fold scans, in the order it meets them, with\n\
-- its direct callees: producer data, each list checked against its\n\
-- function's code above.\n\
def closureCallees : List (Nat × List Nat) :=\n {}\n\n\
theorem closure_callees : AverCert.ScaleClosure.calleesOk AverCert.ArtifactBytes.chunks\n \
layout closureCallees = true :=\n {proof}\n\n",
right_nested(&names)
);
if !split {
return (format!("{}{join}", texts.concat()), Vec::new());
}
let files = texts
.chunks(CLOSURE_BLOCKS_PER_MODULE)
.enumerate()
.map(|(m, chunk)| {
(
format!("ArtifactClosure{m}.lean"),
format!(
"-- Blocks of the closure's declared callee lists (`ArtifactClosure`).\n\
import ArtifactLayout\n\
import ScaleClosure\n\n\
set_option maxRecDepth 200000\n\n\
namespace AverCert.Artifact\n\
open AverCert.DeclaredLayout\n\n\
{}\
end AverCert.Artifact\n",
chunk.concat()
),
)
})
.collect();
(join, files)
}
fn rest_parts(layout: bool, data_blocks: Option<&str>) -> Vec<(&'static str, String)> {
if !layout {
return Vec::new();
}
const BYTES: &str = "AverCert.ArtifactBytes.modBytes AverCert.ArtifactBytes.modLen";
const DECLS: &str = "AverCert.manifest.subject AverCert.manifest.types AverCert.manifest.fnPlans";
const TYPES_PLANS: &str = "AverCert.manifest.types AverCert.manifest.fnPlans";
let m = format!("(AverCert.TypeTable.mctxOf {DECLS})");
vec![
(
"ArtifactRest",
format!(
"theorem rest_indices : indicesDistinct {m} AverCert.manifest.fnPlans = true :=\n \
AverCert.SortedKeys.indicesDistinct_of_bits (by decide +kernel)\n\n"
),
),
(
"ArtifactRestTypes",
format!(
"theorem rest_types : AverCert.TypeTable.typeTableConfirmed {BYTES}\n \
{DECLS} = true :=\n \
AverCert.ScaleTables.typeTableConfirmed_of_layout bytes_eq chunks_fit types_head\n \
types_walk types_tiled rec_tiled rec_subs types_single (by decide +kernel)\n\n"
),
),
(
"ArtifactRestData",
match data_blocks {
Some(text) => text.to_string(),
None => format!(
"theorem rest_data : AverCert.TypeTable.dataConfirmed {BYTES}\n \
{DECLS} = true := by\n \
decide +kernel\n\n"
),
},
),
(
"ArtifactRestRoles",
format!(
"theorem rest_roles : AverCert.DeclaredLayout.roleTypesPinnedL layout {BYTES}\n \
{m} = true := by\n \
simp -iota only [AverCert.DeclaredLayout.roleTypesPinnedL,\n \
AverCert.DeclaredLayout.roleTypePinnedL, type_matches]\n \
decide +kernel\n\n"
),
),
(
"ArtifactRest",
format!(
"theorem rest_eqref : AverCert.TypeTable.eqrefConfined {TYPES_PLANS} = true := by\n \
decide +kernel\n\n\
theorem rest_newtypes : AverCert.TypeTable.newtypesGrounded AverCert.manifest.types = true := by\n \
decide +kernel\n\n\
theorem rest_inhabited : AverCert.TypeTable.typesInhabited {m}\n \
{TYPES_PLANS} = true := by\n \
decide +kernel\n\n\
theorem rest_cons : AverCert.AcceptedArtifact.consPinned {TYPES_PLANS} = true := by\n \
decide +kernel\n\n"
),
),
(
"ArtifactRestHelpers",
format!(
"theorem rest_helpers : AverCert.DeclaredLayout.listHelpersPinnedL layout {BYTES}\n \
{m} = true := by\n \
simp -iota only [AverCert.DeclaredLayout.listHelpersPinnedL,\n \
AverCert.AcceptedArtifact.listHelpersPinnedWith, AverCert.DeclaredLayout.roleTypePinnedL,\n \
type_matches]\n \
decide +kernel\n\n"
),
),
]
}
fn render_final() -> String {
format!(
"import Artifact\nimport AcceptanceSoundness\n\n\
open AverCert AverCert.Schema\n\n\
/-- THE certificate theorem: every certified export's emitted function\n\
simulates its plan's model, from the acceptance's byte facts. -/\n\
{FINAL_STATEMENT_LINE} :=\n \
AcceptanceSoundness.accept_sound CertModule.wasmSha256 AverCert.Artifact.data\n \
rfl rfl rfl rfl AverCert.Artifact.plans_ok\n\n\
#print axioms {FINAL_THEOREM}\n"
)
}
fn render_artifact_certificate() -> String {
"import Artifact\nimport Final\nimport ArtifactReports\n\n\
namespace AverCert.Artifact\n\n\
theorem certificate : AverCert.AcceptedArtifact.accepted data :=\n \
⟨AverCert.Final.cert, envelope_ok, rfl, rfl, plans_ok, roles_ok, strings_ok, axes_ok, whole_ok⟩\n\n\
#print axioms AverCert.Artifact.certificate\n\n\
end AverCert.Artifact\n"
.to_string()
}
fn json_list<T>(items: &[T], render: impl Fn(&T) -> String) -> String {
if items.is_empty() {
return "[]".to_string();
}
format!(
"[\n{}\n ]",
items
.iter()
.map(|x| format!(" {}", render(x)))
.collect::<Vec<_>>()
.join(",\n")
)
}
fn render_manifest_json(
analysis: &Analysis,
artifact_file_name: &str,
sha: &str,
target: &str,
abi: &str,
envelope: Option<crate::format::Wasip2ComponentEnvelopeDeclaration>,
surfaces: &Surfaces,
) -> String {
let laws = &surfaces.law_claims;
let law_bridges = &surfaces.law_bridge_exports;
let bridges = surfaces.packaged_bridges();
let declined_bridges = &surfaces.declined_bridges;
let any_total = analysis.certified.iter().any(|c| c.total);
let any_partial = analysis.certified.iter().any(|c| !c.total);
let level = match (any_partial, any_total) {
(true, true) => "mixed L1/L3",
(false, true) => "L3",
_ => CERT_LEVEL,
};
let mut s = String::from("{\n");
s.push_str(&format!(" \"schema_version\": {CERT_SCHEMA_VERSION},\n"));
s.push_str(&format!(
" \"format\": {{\"version\": {}, \"wall_id\": {}}},\n",
wall::FORMAT_VERSION,
json_str(wall::current_id())
));
s.push_str(&format!(" \"wasm\": {},\n", json_str(artifact_file_name)));
s.push_str(&format!(" \"wasm_sha256\": \"{sha}\",\n"));
s.push_str(&format!(" \"target\": {},\n", json_str(target)));
s.push_str(&format!(" \"level\": \"{level}\",\n"));
s.push_str(&format!(" \"profile\": \"{PROFILE_ID}\",\n"));
s.push_str(&format!(" \"abi\": {},\n", json_str(abi)));
if let Some(envelope) = envelope {
s.push_str(&format!(
" \"{}\": {{\"{}\": {}, \"{}\": {}, \"{}\": {}, \"{}\": {}}},\n",
crate::format::WASIP2_COMPONENT_ENVELOPE_FIELD,
crate::format::WASIP2_COMPONENT_ENVELOPE_KIND_FIELD,
json_str(envelope.kind()),
crate::format::WASIP2_COMPONENT_ENVELOPE_PREFIX_LEN_FIELD,
envelope.prefix_len,
crate::format::WASIP2_COMPONENT_ENVELOPE_CORE_LEN_FIELD,
envelope.embedded_core_module_len,
crate::format::WASIP2_COMPONENT_ENVELOPE_SUFFIX_LEN_FIELD,
envelope.suffix_len,
));
}
s.push_str(&format!(" \"final_theorem\": \"{FINAL_THEOREM}\",\n"));
s.push_str(&format!(
" \"artifact_certificate_root\": \"{ARTIFACT_CERTIFICATE_ROOT}\",\n"
));
match analysis.carrier {
Some(c) => s.push_str(&format!(" \"carrier_type_index\": {c},\n")),
None => s.push_str(" \"carrier_type_index\": null,\n"),
}
s.push_str(&format!(
" \"runtime_contracts\": {},\n",
json_list(&analysis.contracts, |c| json_str(c))
));
let bridge_exports: Vec<&str> = bridges.iter().map(|b| b.export.as_str()).collect();
s.push_str(&format!(
" \"laws\": {},\n",
json_list(
&laws.iter().zip(law_bridges).collect::<Vec<_>>(),
|(claim, cited)| {
let cited: Vec<&String> = if cited.iter().all(|e| bridge_exports.contains(&e.as_str())) {
cited.iter().collect()
} else {
Vec::new()
};
format!(
"{{\"label\": {}, \"theorem\": {}, \"statement\": {}, \"corollary\": {}, \"bridges\": [{}]}}",
json_str(&claim.label),
json_str(&claim.qualified()),
json_str(&claim.statement),
json_str(&claim.corollary()),
cited.iter().map(|e| json_str(e)).collect::<Vec<_>>().join(", ")
)
}
)
));
s.push_str(&format!(
" \"sourceBridges\": {},\n",
json_list(bridges, SourceBridge::to_json)
));
s.push_str(&format!(
" \"sourceBridgesDeclined\": {},\n",
json_list(declined_bridges, |(e, r)| format!(
"{{\"export\": {}, \"reason\": {}}}",
json_str(e),
json_str(r)
))
));
s.push_str(&format!(
" \"declaredUncertified\": {},\n",
json_list(&declared_uncertified(analysis), |(n, r)| format!(
"{{\"name\": {}, \"reason\": {}}}",
json_str(n),
json_str(r)
))
));
s.push_str(&format!(
" \"capabilities\": {},\n",
json_list(&analysis.module_envelope.capabilities, |(m, n)| format!(
"{{\"module\": {}, \"name\": {}}}",
json_str(m),
json_str(n)
))
));
match analysis.module_envelope.start {
Some(i) => s.push_str(&format!(
" \"start\": {{\"present\": true, \"function_index\": {i}}},\n"
)),
None => s.push_str(" \"start\": {\"present\": false, \"function_index\": null},\n"),
}
let role = |i: Option<u32>| i.map_or_else(|| "null".to_string(), |i| i.to_string());
match &analysis.roles {
Some(r) => s.push_str(&format!(
" \"hostRoleTable\": {{\"box\": {}, \"add\": {}, \"mul\": {}, \"sub\": {}, \"toIndex\": {}, \"cmp\": {}, \"eq\": {}, \"divmod\": {}}},\n",
role(r.box_idx),
role(r.add_idx),
role(r.mul_idx),
role(r.sub_idx),
role(r.to_index_idx),
role(r.cmp_idx),
role(r.eq_idx),
role(r.divmod_idx),
)),
None => s.push_str(" \"hostRoleTable\": null,\n"),
}
s.push_str(&format!(
" \"stringHostRoles\": [{}],\n",
analysis
.string_roles
.iter()
.map(|(i, r)| format!(
"{{\"function_index\": {i}, \"role\": {}}}",
json_str(r.manifest_value())
))
.collect::<Vec<_>>()
.join(", ")
));
s.push_str(&format!(
" \"certified\": {},\n",
json_list(&analysis.certified, |c| {
let (policy, level, termination) = if c.total {
(
"simulatesModelTotally",
"L3",
", \"termination_witness\": {\"measure\": {\"kind\": \"intNatAbs\", \"param_index\": 0}, \"descent\": -1}",
)
} else {
("simulatesModel", "L1", "")
};
format!(
"{{\"name\": {}, \"class\": \"{PLAN_CLASS}\", \"facets\": [{}], \"policy\": \"{policy}\", \"level\": \"{level}\", \"theorem\": \"{FN_CLAIM_DISCHARGE_THEOREM}\"{termination}}}",
json_str(&c.name),
c.facets.iter().map(|f| json_str(f)).collect::<Vec<_>>().join(", ")
)
})
));
s.push_str(&format!(
" \"source_level_only\": {}\n",
json_list(&analysis.declined, |(n, r)| format!(
"{{\"name\": {}, \"reason\": {}}}",
json_str(n),
json_str(r)
))
));
s.push_str("}\n");
s
}
pub fn write_project(
out_dir: &Path,
artifact: CertificateArtifact<'_>,
analysis: &Analysis,
model: &SourceModel,
) -> Result<ProjectDeclines, String> {
artifact.validate()?;
let cert_dir = out_dir.join("cert");
match std::fs::remove_dir_all(&cert_dir) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => return Err(format!("replace cert dir: {error}")),
}
std::fs::create_dir_all(&cert_dir).map_err(|e| format!("create cert dir: {e}"))?;
let sha = sha256_hex(artifact.delivered_bytes());
let target = artifact.target();
let abi = artifact.abi();
let envelope = artifact.wasip2_component_envelope();
write(&cert_dir, "Plans.lean", &render_plans(analysis))?;
let layout = !analysis.entries.is_empty();
let (decls, sites, declared_pieces, strings, data, helper_sites) = if layout {
let LayoutParts {
text,
extra,
decls,
sites,
walk,
strings,
data,
helper_sites,
} = render_artifact_layout(artifact.core_module_bytes(), analysis)?;
write(&cert_dir, "ArtifactLayout.lean", &text)?;
for (name, text) in extra {
write(&cert_dir, &name, &text)?;
}
for (name, text) in render_artifact_exports(&walk) {
write(&cert_dir, &name, &text)?;
}
(decls, sites, Some(walk.declared_pieces()), Some(strings), data, helper_sites)
} else {
(Vec::new(), Vec::new(), None, None, None, Vec::new())
};
write(
&cert_dir,
"Manifest.lean",
&render_manifest_lean(analysis, &sha, target, abi, declared_pieces.as_deref()),
)?;
if let Some(params) = analysis
.roles
.as_ref()
.and_then(|r| r.arith_params_record_lean(analysis.carrier))
{
write(
&cert_dir,
"ArtifactHostRoles.lean",
&render_artifact_host_roles(analysis, ¶ms, layout),
)?;
}
for (name, text) in render_artifact_plans(analysis, &decls, &sites, layout) {
write(&cert_dir, &name, &text)?;
}
for (name, text) in render_artifact(
analysis,
envelope,
strings.as_deref(),
data.as_deref(),
&helper_sites,
) {
write(&cert_dir, &name, &text)?;
}
write(&cert_dir, "Final.lean", &render_final())?;
for (name, text) in render_report_blocks(analysis) {
write(&cert_dir, &name, &text)?;
}
write(
&cert_dir,
"ArtifactCertificate.lean",
&render_artifact_certificate(),
)?;
let surfaces = plan_surfaces(analysis, model);
if surfaces.bridge_lean.is_some() || surfaces.laws_lean.is_some() {
for (path, content) in &surfaces.model.files {
write_nested(&cert_dir, path, content)?;
}
}
if let Some((corollaries, parts)) = &surfaces.bridge_lean {
for (name, text) in parts {
write(&cert_dir, name, text)?;
}
write(&cert_dir, "Bridge.lean", corollaries)?;
}
if let Some(laws_lean) = &surfaces.laws_lean {
write(&cert_dir, "Laws.lean", laws_lean)?;
}
std::fs::write(
cert_dir.join("cert-manifest.json"),
render_manifest_json(
analysis,
artifact.file_name(),
&sha,
target,
abi,
envelope,
&surfaces,
),
)
.map_err(|e| format!("write manifest: {e}"))?;
Ok(ProjectDeclines {
law_claims: surfaces.declined_laws,
source_bridges: surfaces.declined_bridges,
})
}
fn write_nested(dir: &Path, name: &str, content: &str) -> Result<(), String> {
let path = dir.join(name);
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| format!("create directory for {name}: {e}"))?;
}
std::fs::write(&path, content).map_err(|e| format!("write {}: {e}", path.display()))
}
#[cfg(test)]
mod name_key_order_tests {
use super::name_key_order;
fn seq_key(name: &str) -> u128 {
name.chars().rev().fold(0u128, |key, c| {
u128::from(u32::from(c)) + 1 + 2_097_152 * key
})
}
#[test]
fn name_key_order_is_the_wall_key_order() {
let names = [
"", "a", "b", "z", "ab", "ba", "zz", "aaa", "_st", "size", "é", "aé", "éa", "mem",
"__a", "abcde", "bbcde", "abcdf",
];
for a in names {
for b in names {
assert_eq!(
name_key_order(a).cmp(&name_key_order(b)),
seq_key(a).cmp(&seq_key(b)),
"{a:?} vs {b:?}"
);
}
}
}
}