1pub mod cache;
12pub mod capability_cells_gate;
13mod composition_gate;
14pub mod config;
15pub mod consistency_gate;
16pub mod diff;
17pub mod duplicate_stems;
18pub mod evidence_gate;
19pub mod finding;
20mod gates;
21pub use gates::{collect_yaml_files, UNWALKED_DIRS};
22pub mod bindings_gate;
23mod gates_extended;
24pub mod ratchet_gates;
25pub mod references_gate;
26pub mod refinement_gate;
27pub mod refines_gate;
28pub mod relations_gate;
29pub mod rules;
30pub mod sarif;
31pub mod shapes_gate;
32pub mod sigma_gate;
33pub mod sigma_symbols;
34mod strict_test_binding;
35pub mod subsumption;
36pub mod tbox_gate;
37pub mod trend;
38pub mod valid_under_gate;
39
40use std::collections::{HashMap, HashSet};
41use std::path::Path;
42use std::time::Instant;
43
44use serde::Serialize;
45
46use self::finding::LintFinding;
47use self::gates::{
48 load_binding, load_contracts, run_audit_gate, run_score_gate, run_validate_gate,
49};
50use self::gates_extended::{
51 check_stale_suppressions, run_enforce_gate, run_enforcement_level_gate,
52 run_reverse_coverage_gate, run_verify_gate,
53};
54use self::rules::RuleSeverity;
55use crate::ontology::arming::{meet_armed, ArmedGates};
56use crate::ontology::verdict::Verdict;
57
58#[derive(Debug, Clone, Serialize)]
60pub struct GateResult {
61 pub name: String,
62 pub passed: bool,
63 pub skipped: bool,
64 pub verdict: Verdict,
66 pub duration_ms: u64,
67 pub detail: GateDetail,
68 #[serde(default, skip_serializing_if = "Option::is_none")]
75 pub extra: Option<GateExtra>,
76}
77
78#[derive(Debug, Clone, Serialize)]
97#[serde(tag = "type")]
98pub enum GateDetail {
99 #[serde(rename = "validate")]
100 Validate {
101 contracts: usize,
102 errors: usize,
103 warnings: usize,
104 error_messages: Vec<String>,
105 },
106 #[serde(rename = "audit")]
107 Audit {
108 contracts: usize,
109 findings: usize,
110 finding_messages: Vec<String>,
111 },
112 #[serde(rename = "score")]
113 Score {
114 contracts: usize,
115 min_score: f64,
116 mean_score: f64,
117 threshold: f64,
118 below_threshold: Vec<String>,
119 },
120 #[serde(rename = "verify")]
121 Verify {
122 total_refs: usize,
123 existing: usize,
124 missing: usize,
125 },
126 #[serde(rename = "enforce")]
127 Enforce {
128 equations_total: usize,
129 equations_with_pre: usize,
130 equations_with_post: usize,
131 equations_with_lean: usize,
132 },
133 #[serde(rename = "reverse_coverage")]
134 ReverseCoverage {
135 total_pub_fns: usize,
136 bound_fns: usize,
137 unbound_fns: usize,
138 coverage_pct: f64,
139 threshold_pct: f64,
140 },
141 #[serde(rename = "composition")]
142 Composition {
143 edges_checked: usize,
144 edges_satisfied: usize,
145 edges_broken: usize,
146 },
147 #[serde(rename = "skipped")]
148 Skipped { reason: String },
149}
150
151#[derive(Debug, Clone, Serialize)]
154pub struct ShapesControls {
155 pub pc_extract: std::collections::BTreeMap<String, String>,
157 pub pc_shapes: std::collections::BTreeMap<String, String>,
160 #[serde(skip_serializing_if = "Option::is_none")]
163 pub capability_cells: Option<capability_cells_gate::CapabilityCellsReport>,
164}
165
166#[allow(clippy::large_enum_variant)]
190#[derive(Debug, Clone, Serialize)]
191#[serde(tag = "type")]
193#[non_exhaustive]
194pub enum GateExtra {
195 #[serde(rename = "duplicate_stems")]
197 DuplicateStems {
198 divergent: usize,
200 baselined: usize,
202 unbaselined: Vec<String>,
204 stale: Vec<String>,
206 divergent_stems: Vec<String>,
208 },
209 #[serde(rename = "sigma")]
211 Sigma {
212 entity_types: usize,
214 roles: usize,
216 symbols: usize,
218 contracts_checked: usize,
220 violations: usize,
222 formal_total: usize,
224 formal_prose: usize,
226 },
227 #[serde(rename = "relations")]
229 Relations {
230 relations_n: usize,
232 contracts_with_relations: usize,
234 roles_used: Vec<String>,
236 cycles: Vec<String>,
238 legacy_depends_on: usize,
240 legacy_unresolved_depends_on: usize,
242 violations: usize,
244 },
245 #[serde(rename = "evidence")]
247 Evidence {
248 contracts_checked: usize,
250 contracts_with_evidence: usize,
252 entity_types_checked: usize,
254 entity_types: Vec<String>,
256 levels_source: String,
258 by_level: Vec<String>,
260 census_git_sha: Option<String>,
262 unresolved_git_shas: usize,
264 violations: usize,
266 },
267 #[serde(rename = "valid_under")]
269 ValidUnder {
270 worlds: Vec<String>,
272 contracts_checked: usize,
274 kernel_contracts: usize,
276 contracts_with_valid_under: usize,
278 contracts_without_valid_under: usize,
280 baseline: Option<usize>,
282 by_world: Vec<String>,
284 violations: usize,
286 },
287 #[serde(rename = "theorem_pairing")]
289 TheoremPairing {
290 lean_base: String,
292 book_pages: usize,
294 theorem_modules: usize,
296 paired: usize,
298 unpaired_theorem_modules: usize,
300 baseline: Option<usize>,
302 unpaired: Vec<String>,
304 violations: usize,
306 },
307 #[serde(rename = "depends_on_present")]
309 DependsOnPresent {
310 contracts_checked: usize,
312 kernel_contracts: usize,
314 contracts_without_depends_on: usize,
316 baseline: Option<usize>,
318 violations: usize,
320 },
321 #[serde(rename = "references_resolve")]
323 ReferencesResolve {
324 contracts_checked: usize,
326 path_references: usize,
328 dead_references: usize,
330 baseline: Option<usize>,
332 dead: Vec<String>,
334 violations: usize,
336 },
337 #[serde(rename = "proved_is_derived")]
339 ProvedIsDerived {
340 summary: Option<String>,
342 summary_error: Option<String>,
344 summary_green: bool,
346 contracts_checked: usize,
348 proved_claims: usize,
350 underived_proved_claims: usize,
352 baseline: Option<usize>,
354 underived: Vec<String>,
356 violations: usize,
358 },
359 #[serde(rename = "challenge_fresh")]
361 ChallengeFresh {
362 lean_dir: String,
364 files: usize,
366 stale: Vec<String>,
368 unrestated: Vec<String>,
370 },
371 #[serde(rename = "shapes")]
373 Shapes {
374 shapes_n: usize,
376 focus_nodes_n: usize,
378 pc_shape: String,
380 plant_violations: usize,
382 violations: usize,
384 warnings: usize,
386 by_shape: Vec<String>,
388 triples: usize,
390 armed_shapes: Vec<String>,
392 not_armed_shapes: Vec<String>,
394 declines: Vec<String>,
415 unarmed_violations: usize,
417 by_entity_type: std::collections::BTreeMap<String, usize>,
419 #[serde(flatten)]
423 controls: Box<ShapesControls>,
424 receipts: usize,
426 witnesses: usize,
428 hex_mismatches: usize,
430 unmeasured_rows: usize,
432 w3c_cases_passed: usize,
434 w3c_cases_n: usize,
435 #[serde(flatten)]
439 counters: Box<ShapesCounters>,
440 #[serde(skip_serializing_if = "Option::is_none")]
442 release: Option<Box<crate::ontology::extract::release_evidence::ReleaseStats>>,
443 readme: MeasuredSet,
445 claude_md: MeasuredSet,
447 ratchets: Ratchets,
449 },
450 #[serde(rename = "ont_consistency")]
452 Consistency {
453 checkable_n: usize,
455 units: usize,
457 unencoded_edges: usize,
459 pc_checker: String,
461 core: Vec<String>,
463 violations: usize,
465 witness: consistency_gate::WitnessReport,
467 },
468 #[serde(rename = "refines")]
470 Refines(Box<refines_gate::RefinesCounters>),
471 #[serde(rename = "bindings")]
473 Bindings(Box<bindings_gate::BindingsCounters>),
474 #[serde(rename = "refinement")]
476 Refinement(Box<refinement_gate::RefinementCounters>),
477}
478
479#[derive(Debug, Clone, Default, Serialize)]
481pub struct ShapesCounters {
482 pub symbols_resolved: usize,
484 pub symbols_unresolved: usize,
485 pub lean_statements: usize,
487 pub lean_refs_unresolved: usize,
488 pub inherited_shapes_applied: usize,
493 pub inherited_by_shape: Vec<String>,
495}
496
497#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
499pub struct MeasuredSet {
500 pub verified_commands: Vec<String>,
501}
502
503#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
506pub struct Ratchets {
507 pub measured_sets: String,
508}
509
510impl Default for Ratchets {
511 fn default() -> Self {
512 Self {
513 measured_sets: "not-checked".into(),
514 }
515 }
516}
517
518#[derive(Debug, Clone, Serialize)]
520pub struct LintReport {
521 pub passed: bool,
522 pub gates: Vec<GateResult>,
523 pub total_duration_ms: u64,
524 #[serde(skip_serializing_if = "Vec::is_empty")]
525 pub findings: Vec<LintFinding>,
526 #[serde(skip)]
527 pub cache_stats: cache::CacheStats,
528 #[serde(default, skip_serializing_if = "Vec::is_empty")]
530 pub contract_timings: Vec<(String, u64)>,
531 pub verdict: Verdict,
534 pub armed_gates: Vec<ArmedGateVerdict>,
536 pub not_armed: Vec<String>,
538 #[serde(skip_serializing_if = "Option::is_none")]
540 pub armed_monotone: Option<String>,
541 #[serde(skip_serializing_if = "Option::is_none")]
543 pub armed_shapes_monotone: Option<String>,
544}
545
546#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
548pub struct ArmedGateVerdict {
549 pub name: String,
550 pub verdict: Verdict,
551}
552
553impl LintReport {
554 pub fn arm(&mut self, armed: &ArmedGates) {
556 let results: Vec<(String, Verdict)> = self
557 .gates
558 .iter()
559 .map(|g| (g.name.clone(), g.verdict))
560 .collect();
561 let meet = meet_armed(&results, armed);
562 self.verdict = meet.verdict;
563 self.armed_gates = meet
564 .armed
565 .into_iter()
566 .map(|(name, verdict)| ArmedGateVerdict { name, verdict })
567 .collect();
568 self.not_armed = meet.not_armed;
569 }
570}
571
572pub struct LintConfig<'a> {
574 pub contract_dir: &'a Path,
575 pub binding_path: Option<&'a Path>,
576 pub min_score: f64,
577 pub severity_filter: Option<RuleSeverity>,
578 pub severity_overrides: HashMap<String, RuleSeverity>,
579 pub suppressed_findings: Vec<String>,
580 pub suppressed_rules: Vec<String>,
581 pub suppressed_files: Vec<String>,
582 pub strict: bool,
583 pub no_cache: bool,
584 pub cache_stats: bool,
585 pub crate_dir: Option<&'a Path>,
587 pub min_level: Option<crate::schema::EnforcementLevel>,
589 pub strict_test_binding: bool,
591 pub strict_test_binding_only: bool,
595}
596
597impl<'a> LintConfig<'a> {
598 pub fn new(contract_dir: &'a Path, binding_path: Option<&'a Path>, min_score: f64) -> Self {
600 Self {
601 contract_dir,
602 binding_path,
603 min_score,
604 severity_filter: None,
605 severity_overrides: HashMap::new(),
606 suppressed_findings: Vec::new(),
607 suppressed_rules: Vec::new(),
608 suppressed_files: Vec::new(),
609 strict: false,
610 no_cache: false,
611 cache_stats: false,
612 crate_dir: None,
613 min_level: None,
614 strict_test_binding: false,
615 strict_test_binding_only: false,
616 }
617 }
618}
619
620fn push_gate<F>(
625 gates: &mut Vec<GateResult>,
626 all_findings: &mut Vec<LintFinding>,
627 run: F,
628 name: &str,
629 validation_passed: bool,
630) where
631 F: FnOnce() -> (GateResult, Vec<LintFinding>),
632{
633 let (result, mut findings) = if validation_passed {
634 run()
635 } else {
636 (skipped_gate(name, "validation failed"), Vec::new())
637 };
638 gates.push(result);
639 all_findings.append(&mut findings);
640}
641
642fn per_contract_timings(
645 contracts: &[(String, crate::schema::Contract)],
646 binding: Option<&crate::binding::BindingRegistry>,
647) -> Vec<(String, u64)> {
648 let mut contract_timings: Vec<(String, u64)> = Vec::with_capacity(contracts.len());
649 for (stem, contract) in contracts {
650 let ct_start = Instant::now();
651 let _ = crate::schema::validate_contract(contract);
653 let _ = crate::audit::audit_contract(contract);
655 let _ = crate::scoring::score_contract(contract, binding, stem);
657 let ct_ms = u64::try_from(ct_start.elapsed().as_micros() / 1000).unwrap_or(0);
658 contract_timings.push((format!("{stem}.yaml"), ct_ms));
659 }
660 contract_timings.sort_by_key(|b| std::cmp::Reverse(b.1));
662 contract_timings
663}
664
665fn store_findings_in_cache(
667 root: &std::path::Path,
668 config: &LintConfig,
669 contracts: &[(String, crate::schema::Contract)],
670 all_findings: &[LintFinding],
671 stats: &mut cache::CacheStats,
672) {
673 let rule_cfg = format!("{:?}{:?}", config.severity_overrides, config.strict);
674 for (stem, _) in contracts {
675 stats.total += 1;
676 let yaml_path = config.contract_dir.join(format!("{stem}.yaml"));
677 let yaml_content = std::fs::read_to_string(&yaml_path).unwrap_or_default();
678 let hash = cache::content_hash(&yaml_content, &rule_cfg);
679 if cache::cache_get(root, &hash).is_some() {
680 stats.hits += 1;
681 } else {
682 stats.misses += 1;
683 let contract_findings: Vec<_> = all_findings
684 .iter()
685 .filter(|f| f.contract_stem.as_deref() == Some(stem.as_str()))
686 .cloned()
687 .collect();
688 let _ = cache::cache_put(root, &hash, &contract_findings);
689 }
690 }
691}
692
693fn run_gates_2_to_9(
696 config: &LintConfig,
697 contracts: &[(String, crate::schema::Contract)],
698 binding: Option<&crate::binding::BindingRegistry>,
699 validation_passed: bool,
700 gates: &mut Vec<GateResult>,
701 all_findings: &mut Vec<LintFinding>,
702) {
703 push_gate(
705 gates,
706 all_findings,
707 || run_audit_gate(contracts),
708 "audit",
709 validation_passed,
710 );
711
712 push_gate(
714 gates,
715 all_findings,
716 || run_score_gate(contracts, binding, config.min_score),
717 "score",
718 validation_passed,
719 );
720
721 push_gate(
723 gates,
724 all_findings,
725 || {
726 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
727 run_verify_gate(contracts, project_root)
728 },
729 "verify",
730 validation_passed,
731 );
732
733 push_gate(
735 gates,
736 all_findings,
737 || run_enforce_gate(contracts),
738 "enforce",
739 validation_passed,
740 );
741
742 push_gate(
744 gates,
745 all_findings,
746 || {
747 let min_level = config
748 .min_level
749 .unwrap_or(crate::schema::EnforcementLevel::Standard);
750 run_enforcement_level_gate(contracts, min_level)
751 },
752 "enforcement-level",
753 validation_passed,
754 );
755
756 push_gate(
758 gates,
759 all_findings,
760 || match (config.binding_path, config.crate_dir) {
761 (Some(bp), Some(cd)) => run_reverse_coverage_gate(bp, cd),
762 _ => (
763 skipped_gate("reverse-coverage", "no --binding or --crate-dir provided"),
764 Vec::new(),
765 ),
766 },
767 "reverse-coverage",
768 validation_passed,
769 );
770
771 let duplicates = duplicate_stems::scan_duplicate_stems(config.contract_dir);
775 let ambiguous = duplicate_stems::ambiguous_stems(&duplicates);
776 push_gate(
777 gates,
778 all_findings,
779 || {
780 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
781 let baseline = duplicate_stems::read_baseline(project_root);
782 duplicate_stems::run_duplicate_stem_gate(&duplicates, &baseline)
783 },
784 "duplicate-stems",
785 validation_passed,
786 );
787
788 push_gate(
790 gates,
791 all_findings,
792 || composition_gate::run_composition_gate(contracts, &ambiguous),
793 "composition",
794 validation_passed,
795 );
796}
797
798fn run_ontology_gates_10_to_22(
801 contract_dir: &Path,
802 validation_passed: bool,
803 gates: &mut Vec<GateResult>,
804 all_findings: &mut Vec<LintFinding>,
805) {
806 let (sigma_gate_result, mut sigma_findings) = sigma_result(contract_dir, validation_passed);
809 gates.push(sigma_gate_result);
810 all_findings.append(&mut sigma_findings);
811
812 let (relations_gate_result, mut relations_findings) =
814 relations_result(contract_dir, validation_passed);
815 gates.push(relations_gate_result);
816 all_findings.append(&mut relations_findings);
817
818 let (shapes_gate_result, mut shapes_findings) = shapes_result(contract_dir, validation_passed);
820 gates.push(shapes_gate_result);
821 all_findings.append(&mut shapes_findings);
822
823 let (valid_under_gate_result, mut valid_under_findings) =
825 valid_under_result(contract_dir, validation_passed);
826 gates.push(valid_under_gate_result);
827 all_findings.append(&mut valid_under_findings);
828
829 for (name, run) in RATCHET_GATES {
832 let (result, mut findings) = ratchet_result(contract_dir, validation_passed, name, run);
833 gates.push(result);
834 all_findings.append(&mut findings);
835 }
836
837 gates.push(challenge_result(contract_dir));
840
841 let (consistency_gate_result, mut consistency_findings) =
844 consistency_result(contract_dir, validation_passed);
845 gates.push(consistency_gate_result);
846 all_findings.append(&mut consistency_findings);
847
848 let (refines_gate_result, mut refines_findings) =
850 refines_result(contract_dir, validation_passed);
851 gates.push(refines_gate_result);
852 all_findings.append(&mut refines_findings);
853
854 let (bindings_gate_result, mut bindings_findings) = ratchet_result(
856 contract_dir,
857 validation_passed,
858 bindings_gate::GATE,
859 bindings_gate::run_bindings_gate,
860 );
861 gates.push(bindings_gate_result);
862 all_findings.append(&mut bindings_findings);
863
864 let (refinement_gate_result, mut refinement_findings) = ratchet_result(
866 contract_dir,
867 validation_passed,
868 refinement_gate::GATE,
869 refinement_gate::run_refinement_gate,
870 );
871 gates.push(refinement_gate_result);
872 all_findings.append(&mut refinement_findings);
873
874 let (evidence_gate_result, mut evidence_findings) =
876 evidence_result(contract_dir, validation_passed);
877 gates.push(evidence_gate_result);
878 all_findings.append(&mut evidence_findings);
879}
880
881fn run_strict_test_binding_gate_if_enabled(
883 config: &LintConfig,
884 contracts: &[(String, crate::schema::Contract)],
885 validation_passed: bool,
886 gates: &mut Vec<GateResult>,
887 all_findings: &mut Vec<LintFinding>,
888) {
889 if !config.strict_test_binding {
890 return;
891 }
892 push_gate(
893 gates,
894 all_findings,
895 || {
896 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
897 strict_test_binding::run_strict_test_binding_gate(
898 contracts,
899 project_root,
900 config.strict,
901 )
902 },
903 "strict-test-binding",
904 validation_passed,
905 );
906}
907
908#[allow(clippy::too_many_arguments)]
911fn finalize_findings(
912 config: &LintConfig,
913 contracts: &[(String, crate::schema::Contract)],
914 binding: Option<&crate::binding::BindingRegistry>,
915 validation_passed: bool,
916 cache_root: Option<&std::path::Path>,
917 stats: &mut cache::CacheStats,
918 all_findings: &mut Vec<LintFinding>,
919 mut validate_findings: Vec<LintFinding>,
920) -> Vec<(String, u64)> {
921 all_findings.append(&mut validate_findings);
922
923 let contract_timings = if validation_passed {
925 per_contract_timings(contracts, binding)
926 } else {
927 Vec::new()
928 };
929
930 let mut stale_findings = check_stale_suppressions(
932 all_findings,
933 &config.suppressed_rules,
934 &config.suppressed_findings,
935 );
936 all_findings.append(&mut stale_findings);
937
938 mark_new_findings(all_findings, config.contract_dir);
940
941 if let Some(root) = cache_root {
943 store_findings_in_cache(root, config, contracts, all_findings, stats);
944 }
945
946 apply_suppressions(all_findings, config);
948 apply_severity_overrides(all_findings, config);
949 if let Some(min_sev) = config.severity_filter {
950 all_findings.retain(|f| f.severity >= min_sev);
951 }
952
953 contract_timings
954}
955
956pub fn run_lint(config: &LintConfig) -> LintReport {
958 let overall_start = Instant::now();
959 let mut gates = Vec::with_capacity(3);
960 let mut all_findings = Vec::new();
961 let mut stats = cache::CacheStats::default();
962
963 let cache_root = if config.no_cache || config.strict_test_binding_only {
965 None
966 } else {
967 Some(cache::cache_dir(config.contract_dir))
968 };
969
970 let (contracts, parse_errors) = load_contracts(config.contract_dir);
971 let binding = load_binding(config.binding_path);
972
973 let (validate_result, validate_findings) = run_validate_gate(&contracts, &parse_errors);
975 let validation_passed = validate_result.passed;
976 gates.push(validate_result);
977
978 if !config.strict_test_binding_only {
979 run_gates_2_to_9(
980 config,
981 &contracts,
982 binding.as_ref(),
983 validation_passed,
984 &mut gates,
985 &mut all_findings,
986 );
987 run_ontology_gates_10_to_22(
988 config.contract_dir,
989 validation_passed,
990 &mut gates,
991 &mut all_findings,
992 );
993 }
994 run_strict_test_binding_gate_if_enabled(
995 config,
996 &contracts,
997 validation_passed,
998 &mut gates,
999 &mut all_findings,
1000 );
1001
1002 let contract_timings = finalize_findings(
1003 config,
1004 &contracts,
1005 binding.as_ref(),
1006 validation_passed,
1007 cache_root.as_deref(),
1008 &mut stats,
1009 &mut all_findings,
1010 validate_findings,
1011 );
1012
1013 let passed = gates.iter().all(|g| g.passed || g.skipped);
1014
1015 let mut report = LintReport {
1016 passed,
1017 gates,
1018 total_duration_ms: u64::try_from(overall_start.elapsed().as_millis()).unwrap_or(u64::MAX),
1019 findings: all_findings,
1020 cache_stats: stats,
1021 contract_timings,
1022 verdict: Verdict::Unknown(crate::ontology::verdict::Reason::NotArmed),
1023 armed_gates: Vec::new(),
1024 not_armed: Vec::new(),
1025 armed_monotone: None,
1026 armed_shapes_monotone: None,
1027 };
1028 report.arm(&ArmedGates::default_set());
1031 report
1032}
1033
1034pub enum NamedGateOutcome {
1036 UnknownGate,
1038 Sigma(sigma_gate::SigmaOutcome),
1040 Relations(relations_gate::RelationsOutcome),
1042 Shapes(shapes_gate::ShapesOutcome),
1044 Consistency(consistency_gate::ConsistencyOutcome),
1046 Refines(refines_gate::RefinesOutcome),
1048 Tbox(tbox_gate::TboxOutcome),
1050 Evidence(evidence_gate::EvidenceOutcome),
1052 ValidUnder(valid_under_gate::ValidUnderOutcome),
1054 Ratchet(ratchet_gates::RatchetOutcome),
1056 Ran {
1058 result: Box<GateResult>,
1059 findings: Vec<LintFinding>,
1060 },
1061}
1062
1063#[must_use]
1069pub fn run_named_gate(contract_dir: &Path, name: &str) -> NamedGateOutcome {
1070 run_named_gate_with(contract_dir, name, &shapes_gate::ShapesOptions::default())
1071}
1072
1073pub fn run_named_gate_with(
1075 contract_dir: &Path,
1076 name: &str,
1077 shapes_opts: &shapes_gate::ShapesOptions,
1078) -> NamedGateOutcome {
1079 match name {
1080 "evidence" => NamedGateOutcome::Evidence(evidence_gate::run_evidence_gate(contract_dir)),
1081 "relations" => {
1082 NamedGateOutcome::Relations(relations_gate::run_relations_gate(contract_dir))
1083 }
1084 "shapes" => {
1085 NamedGateOutcome::Shapes(shapes_gate::run_shapes_gate_with(contract_dir, shapes_opts))
1086 }
1087 "sigma" => NamedGateOutcome::Sigma(sigma_gate::run_sigma_gate(contract_dir)),
1088 consistency_gate::GATE => {
1089 NamedGateOutcome::Consistency(consistency_gate::run_consistency_gate(contract_dir))
1090 }
1091 refines_gate::GATE => {
1092 NamedGateOutcome::Refines(refines_gate::run_refines_gate(contract_dir))
1093 }
1094 bindings_gate::GATE => {
1095 NamedGateOutcome::Ratchet(bindings_gate::run_bindings_gate(contract_dir))
1096 }
1097 refinement_gate::GATE => {
1098 NamedGateOutcome::Ratchet(refinement_gate::run_refinement_gate(contract_dir))
1099 }
1100 "tbox" => NamedGateOutcome::Tbox(tbox_gate::run_tbox_gate(contract_dir)),
1101 "valid-under" => {
1102 NamedGateOutcome::ValidUnder(valid_under_gate::run_valid_under_gate(contract_dir))
1103 }
1104 "theorem-pairing" => {
1105 NamedGateOutcome::Ratchet(ratchet_gates::run_theorem_pairing_gate(contract_dir))
1106 }
1107 "depends-on-present" => {
1108 NamedGateOutcome::Ratchet(ratchet_gates::run_depends_on_present_gate(contract_dir))
1109 }
1110 references_gate::GATE => {
1111 NamedGateOutcome::Ratchet(references_gate::run_references_gate(contract_dir))
1112 }
1113 "proved-is-derived" => {
1114 NamedGateOutcome::Ratchet(ratchet_gates::run_proved_is_derived_gate(contract_dir))
1115 }
1116 "validate" => {
1117 let (contracts, parse_errors) = load_contracts(contract_dir);
1118 let (result, findings) = run_validate_gate(&contracts, &parse_errors);
1119 NamedGateOutcome::Ran {
1120 result: Box::new(result),
1121 findings,
1122 }
1123 }
1124 _ => NamedGateOutcome::UnknownGate,
1125 }
1126}
1127
1128pub const NAMED_GATES: [&str; 15] = [
1130 references_gate::GATE,
1131 bindings_gate::GATE,
1132 refinement_gate::GATE,
1133 "depends-on-present",
1134 "evidence",
1135 consistency_gate::GATE,
1136 "proved-is-derived",
1137 refines_gate::GATE,
1138 "relations",
1139 "shapes",
1140 "sigma",
1141 "tbox",
1142 "theorem-pairing",
1143 "valid-under",
1144 "validate",
1145];
1146
1147type RatchetRun = fn(&Path) -> ratchet_gates::RatchetOutcome;
1149const RATCHET_GATES: [(&str, RatchetRun); 4] = [
1150 ("theorem-pairing", ratchet_gates::run_theorem_pairing_gate),
1151 (
1152 "depends-on-present",
1153 ratchet_gates::run_depends_on_present_gate,
1154 ),
1155 (
1156 "proved-is-derived",
1157 ratchet_gates::run_proved_is_derived_gate,
1158 ),
1159 (references_gate::GATE, references_gate::run_references_gate),
1160];
1161
1162fn ratchet_result(
1165 contract_dir: &Path,
1166 validation_passed: bool,
1167 name: &str,
1168 run: RatchetRun,
1169) -> (GateResult, Vec<LintFinding>) {
1170 if !validation_passed {
1171 return (skipped_gate(name, "validation failed"), Vec::new());
1172 }
1173 match run(contract_dir) {
1174 ratchet_gates::RatchetOutcome::Ran { result, findings } => (*result, findings),
1175 ratchet_gates::RatchetOutcome::Declined(why) => (skipped_gate(name, &why), Vec::new()),
1176 }
1177}
1178
1179fn sigma_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1183 if !validation_passed {
1184 return (skipped_gate("sigma", "validation failed"), Vec::new());
1185 }
1186 match sigma_gate::run_sigma_gate(contract_dir) {
1187 sigma_gate::SigmaOutcome::Ran { result, findings } => (*result, findings),
1188 sigma_gate::SigmaOutcome::NoSigma => (
1189 skipped_gate("sigma", "no contracts/ontology.yaml"),
1190 Vec::new(),
1191 ),
1192 sigma_gate::SigmaOutcome::Malformed(e) => (
1193 skipped_gate("sigma", &format!("Σ is malformed: {e}")),
1194 Vec::new(),
1195 ),
1196 }
1197}
1198
1199fn evidence_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1202 if !validation_passed {
1203 return (skipped_gate("evidence", "validation failed"), Vec::new());
1204 }
1205 match evidence_gate::run_evidence_gate(contract_dir) {
1206 evidence_gate::EvidenceOutcome::Ran { result, findings } => (*result, findings),
1207 evidence_gate::EvidenceOutcome::NoSigma => (
1208 skipped_gate("evidence", "no contracts/ontology.yaml"),
1209 Vec::new(),
1210 ),
1211 evidence_gate::EvidenceOutcome::Malformed(e) => (
1212 skipped_gate("evidence", &format!("Σ is malformed: {e}")),
1213 Vec::new(),
1214 ),
1215 evidence_gate::EvidenceOutcome::NoEvidence { contracts_checked } => (
1216 skipped_gate(
1217 "evidence",
1218 &format!(
1219 "no evidence block in {contracts_checked} contracts — R-2: zero is a decline"
1220 ),
1221 ),
1222 Vec::new(),
1223 ),
1224 }
1225}
1226
1227fn valid_under_result(
1230 contract_dir: &Path,
1231 validation_passed: bool,
1232) -> (GateResult, Vec<LintFinding>) {
1233 if !validation_passed {
1234 return (skipped_gate("valid-under", "validation failed"), Vec::new());
1235 }
1236 match valid_under_gate::run_valid_under_gate(contract_dir) {
1237 valid_under_gate::ValidUnderOutcome::Ran { result, findings } => (*result, findings),
1238 valid_under_gate::ValidUnderOutcome::NoSigma => (
1239 skipped_gate("valid-under", "no contracts/ontology.yaml"),
1240 Vec::new(),
1241 ),
1242 valid_under_gate::ValidUnderOutcome::Malformed(e) => (
1243 skipped_gate("valid-under", &format!("Σ is malformed: {e}")),
1244 Vec::new(),
1245 ),
1246 valid_under_gate::ValidUnderOutcome::NoKernels { contracts_checked } => (
1247 skipped_gate(
1248 "valid-under",
1249 &format!("no kernel-kind contract and no valid_under in {contracts_checked} contracts — R-2: zero is a decline"),
1250 ),
1251 Vec::new(),
1252 ),
1253 }
1254}
1255
1256fn relations_result(
1259 contract_dir: &Path,
1260 validation_passed: bool,
1261) -> (GateResult, Vec<LintFinding>) {
1262 if !validation_passed {
1263 return (skipped_gate("relations", "validation failed"), Vec::new());
1264 }
1265 match relations_gate::run_relations_gate(contract_dir) {
1266 relations_gate::RelationsOutcome::Ran { result, findings } => (*result, findings),
1267 relations_gate::RelationsOutcome::NoSigma => (
1268 skipped_gate("relations", "no contracts/ontology.yaml"),
1269 Vec::new(),
1270 ),
1271 relations_gate::RelationsOutcome::Malformed(e) => (
1272 skipped_gate("relations", &format!("Σ is malformed: {e}")),
1273 Vec::new(),
1274 ),
1275 relations_gate::RelationsOutcome::NoRelations {
1276 contracts_checked,
1277 legacy_depends_on,
1278 } => (
1279 skipped_gate(
1280 "relations",
1281 &format!("no typed relations in {contracts_checked} contracts ({legacy_depends_on} legacy metadata.depends_on edges) — R-2: zero is a decline"),
1282 ),
1283 Vec::new(),
1284 ),
1285 }
1286}
1287
1288fn shapes_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1291 if !validation_passed {
1292 return (skipped_gate("shapes", "validation failed"), Vec::new());
1293 }
1294 match shapes_gate::run_shapes_gate(contract_dir) {
1295 shapes_gate::ShapesOutcome::Ran { result, findings } => (*result, findings),
1296 shapes_gate::ShapesOutcome::Unsupported(e) => (skipped_gate("shapes", &format!("{e}")), Vec::new()),
1297 shapes_gate::ShapesOutcome::ExtractFailed(e) => (skipped_gate("shapes", &format!("{e}")), Vec::new()),
1298 shapes_gate::ShapesOutcome::NoShapes { contracts_checked } => (
1299 skipped_gate("shapes", &format!("no `shape:` block in {contracts_checked} contracts — R-2: zero is a decline")),
1300 Vec::new(),
1301 ),
1302 shapes_gate::ShapesOutcome::NoFocus { shapes_n } => (
1303 skipped_gate("shapes", &format!("{shapes_n} shape(s), no focus node")),
1304 Vec::new(),
1305 ),
1306 shapes_gate::ShapesOutcome::WrongCorpus { shapes_n, expected, found, refused } => (
1307 skipped_gate("shapes", &format!("extract:parity-receipt matched {found} focus node(s) and evidence/parity/EXPECTED_RECEIPTS says {expected} ({shapes_n} shape(s)){} — an extractor that saw the wrong corpus reports the same \"no violations\" as one that saw all of it", if refused.is_empty() { String::new() } else { format!("; refused: {}", refused.join("; ")) })),
1308 Vec::new(),
1309 ),
1310 shapes_gate::ShapesOutcome::HarnessBroken { causes } => (
1311 skipped_gate("shapes", &format!("the CRUX harness measured itself, not apr: {}", causes.join("; "))),
1312 Vec::new(),
1313 ),
1314 shapes_gate::ShapesOutcome::NoReceipts { shapes_n, dir } => (
1315 skipped_gate("shapes", &format!("{shapes_n} shape(s) resolve receipts and the tree holds none under {dir}/ — R-2: unmeasured is a decline")),
1316 Vec::new(),
1317 ),
1318 shapes_gate::ShapesOutcome::EmptyDomain { shapes_n } => (
1319 skipped_gate("shapes", &format!("capability-cells: the required-cell domain D is empty ({shapes_n} shape(s)) — R-2: zero is a decline, never a pass")),
1320 Vec::new(),
1321 ),
1322 shapes_gate::ShapesOutcome::PositiveControlFailed { shapes_n, focus_nodes_n, which } => (
1323 skipped_gate("shapes", &format!("positive control {which} did not fire ({shapes_n} shape(s), {focus_nodes_n} focus node(s)) — the gate cannot reject")),
1324 Vec::new(),
1325 ),
1326 shapes_gate::ShapesOutcome::Differential { shapes_n, focus_nodes_n, passed, n, failed } => {
1327 let mut g = skipped_gate(
1328 "shapes",
1329 &format!(
1330 "W3C SHACL-Core differential: {passed} of {n} vendored case(s) pass; failed: {} ({shapes_n} shape(s), {focus_nodes_n} focus node(s)) — the validator disagrees with the standard, so no corpus verdict",
1331 failed.join(" | ")
1332 ),
1333 );
1334 g.verdict = Verdict::Unknown(crate::ontology::verdict::Reason::Differential);
1335 (g, Vec::new())
1336 }
1337 }
1338}
1339
1340fn consistency_result(
1343 contract_dir: &Path,
1344 validation_passed: bool,
1345) -> (GateResult, Vec<LintFinding>) {
1346 if !validation_passed {
1347 return (
1348 skipped_gate(consistency_gate::GATE, "validation failed"),
1349 Vec::new(),
1350 );
1351 }
1352 let outcome = consistency_gate::run_consistency_gate(contract_dir);
1353 if let consistency_gate::ConsistencyOutcome::Ran { result, findings } = outcome {
1354 return (*result, findings);
1355 }
1356 let mut g = skipped_gate(consistency_gate::GATE, &consistency_gate::why(&outcome));
1357 if let Some(reason) = consistency_gate::decline_reason(&outcome) {
1358 g.verdict = Verdict::Unknown(reason);
1359 }
1360 (g, Vec::new())
1361}
1362
1363fn refines_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1365 if !validation_passed {
1366 return (
1367 skipped_gate(refines_gate::GATE, "validation failed"),
1368 Vec::new(),
1369 );
1370 }
1371 let outcome = refines_gate::run_refines_gate(contract_dir);
1372 if let refines_gate::RefinesOutcome::Ran { result, findings } = outcome {
1373 return (*result, findings);
1374 }
1375 let mut g = skipped_gate(refines_gate::GATE, &refines_gate::why(&outcome));
1376 if let Some(reason) = refines_gate::decline_reason(&outcome) {
1377 g.verdict = Verdict::Unknown(reason);
1378 }
1379 (g, Vec::new())
1380}
1381
1382fn challenge_result(contract_dir: &Path) -> GateResult {
1385 const NAME: &str = "challenge-fresh";
1386 let start = Instant::now();
1387 let root = crate::ontology::extract::repo_root(contract_dir);
1388 let Some(lean) = crate::ontology::extract::lean::base_under(&root) else {
1389 return skipped_gate(NAME, "no Lean theorem base under the repo root");
1390 };
1391 let r = match crate::discharge::challenge::render(&lean, contract_dir) {
1392 Ok(r) => r,
1393 Err(e) => return skipped_gate(NAME, &format!("the Lean tree does not load: {e}")),
1394 };
1395 if r.files.is_empty() && r.unrestated.is_empty() {
1396 return skipped_gate(
1397 NAME,
1398 "zero challenges: no contract binds a theorem — R-2: zero is a decline",
1399 );
1400 }
1401 let stale = crate::discharge::challenge::diff(&lean, &r);
1402 let unrestated: Vec<String> = r
1403 .unrestated
1404 .iter()
1405 .map(|(c, fqn, why)| format!("{c}: {fqn}: {why}"))
1406 .collect();
1407 let passed = stale.is_empty() && unrestated.is_empty();
1408 GateResult {
1409 name: NAME.into(),
1410 passed,
1411 skipped: false,
1412 verdict: Verdict::from_gate(passed, false),
1413 duration_ms: u64::try_from(start.elapsed().as_millis()).unwrap_or(u64::MAX),
1414 detail: GateDetail::Validate {
1416 contracts: r.files.len(),
1417 errors: stale.len() + unrestated.len(),
1418 warnings: 0,
1419 error_messages: stale.iter().chain(&unrestated).cloned().collect(),
1420 },
1421 extra: Some(GateExtra::ChallengeFresh {
1422 lean_dir: lean.display().to_string(),
1423 files: r.files.len(),
1424 stale,
1425 unrestated,
1426 }),
1427 }
1428}
1429
1430fn skipped_gate(name: &str, reason: &str) -> GateResult {
1431 GateResult {
1432 name: name.into(),
1433 passed: false,
1434 skipped: true,
1435 verdict: Verdict::from_gate(false, true),
1436 duration_ms: 0,
1437 detail: GateDetail::Skipped {
1438 reason: reason.into(),
1439 },
1440 extra: None,
1441 }
1442}
1443
1444fn apply_suppressions(findings: &mut [LintFinding], config: &LintConfig) {
1445 for f in findings.iter_mut() {
1446 if config.suppressed_rules.iter().any(|r| r == &f.rule_id) {
1447 f.suppressed = true;
1448 f.suppression_reason = Some("Suppressed by --suppress-rule".into());
1449 }
1450 if let Some(ref stem) = f.contract_stem {
1451 if config.suppressed_findings.iter().any(|s| s == stem) {
1452 f.suppressed = true;
1453 f.suppression_reason = Some("Suppressed by --suppress".into());
1454 }
1455 }
1456 if config.suppressed_files.iter().any(|p| f.file.contains(p)) {
1457 f.suppressed = true;
1458 f.suppression_reason = Some("Suppressed by --suppress-file".into());
1459 }
1460 }
1461}
1462
1463fn pv_state_dir(contract_dir: &Path) -> std::path::PathBuf {
1465 contract_dir.parent().unwrap_or(contract_dir).join(".pv")
1466}
1467
1468fn mark_new_findings(findings: &mut [LintFinding], contract_dir: &Path) {
1471 let state_dir = pv_state_dir(contract_dir);
1472 let previous_path = state_dir.join("lint-previous.json");
1473
1474 let previous: HashSet<String> = std::fs::read_to_string(&previous_path)
1476 .ok()
1477 .and_then(|s| serde_json::from_str(&s).ok())
1478 .unwrap_or_default();
1479
1480 let mut current = HashSet::new();
1482 for f in findings.iter_mut() {
1483 let fp = f.fingerprint();
1484 if !previous.contains(&fp) {
1485 f.is_new = true;
1486 }
1487 current.insert(fp);
1488 }
1489
1490 if let Err(e) = std::fs::create_dir_all(&state_dir) {
1492 eprintln!("pv lint: cannot create {}: {e}", state_dir.display());
1493 return;
1494 }
1495 if let Ok(json) = serde_json::to_string(¤t) {
1496 let _ = std::fs::write(&previous_path, json);
1497 }
1498}
1499
1500fn apply_severity_overrides(findings: &mut [LintFinding], config: &LintConfig) {
1501 for f in findings.iter_mut() {
1502 if let Some(&sev) = config.severity_overrides.get(&f.rule_id) {
1503 f.severity = sev;
1504 }
1505 }
1506 if config.strict {
1507 for f in findings.iter_mut() {
1508 if f.severity == RuleSeverity::Warning {
1509 f.severity = RuleSeverity::Error;
1510 }
1511 }
1512 }
1513}
1514
1515#[cfg(test)]
1516#[path = "mod_tests.rs"]
1517mod tests;