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 mod ggplot2_core_gate;
22pub use gates::{collect_yaml_files, UNWALKED_DIRS};
23pub mod bindings_gate;
24mod gates_extended;
25pub mod ratchet_gates;
26pub mod references_gate;
27pub mod refinement_gate;
28pub mod refines_gate;
29pub mod relations_gate;
30pub mod rules;
31pub mod sarif;
32pub mod shapes_gate;
33pub mod sigma_gate;
34pub mod sigma_symbols;
35mod strict_test_binding;
36pub mod subsumption;
37pub mod tbox_gate;
38pub mod trend;
39pub mod valid_under_gate;
40
41use std::collections::{HashMap, HashSet};
42use std::path::Path;
43use std::time::Instant;
44
45use serde::Serialize;
46
47use self::finding::LintFinding;
48use self::gates::{
49 load_binding, load_contracts, run_audit_gate, run_score_gate, run_validate_gate,
50};
51use self::gates_extended::{
52 check_stale_suppressions, run_enforce_gate, run_enforcement_level_gate,
53 run_reverse_coverage_gate, run_verify_gate,
54};
55use self::rules::RuleSeverity;
56use crate::ontology::arming::{meet_armed, ArmedGates};
57use crate::ontology::verdict::Verdict;
58
59#[derive(Debug, Clone, Serialize)]
61pub struct GateResult {
62 pub name: String,
63 pub passed: bool,
64 pub skipped: bool,
65 pub verdict: Verdict,
67 pub duration_ms: u64,
68 pub detail: GateDetail,
69 #[serde(default, skip_serializing_if = "Option::is_none")]
76 pub extra: Option<GateExtra>,
77}
78
79#[derive(Debug, Clone, Serialize)]
98#[serde(tag = "type")]
99pub enum GateDetail {
100 #[serde(rename = "validate")]
101 Validate {
102 contracts: usize,
103 errors: usize,
104 warnings: usize,
105 error_messages: Vec<String>,
106 },
107 #[serde(rename = "audit")]
108 Audit {
109 contracts: usize,
110 findings: usize,
111 finding_messages: Vec<String>,
112 },
113 #[serde(rename = "score")]
114 Score {
115 contracts: usize,
116 min_score: f64,
117 mean_score: f64,
118 threshold: f64,
119 below_threshold: Vec<String>,
120 },
121 #[serde(rename = "verify")]
122 Verify {
123 total_refs: usize,
124 existing: usize,
125 missing: usize,
126 },
127 #[serde(rename = "enforce")]
128 Enforce {
129 equations_total: usize,
130 equations_with_pre: usize,
131 equations_with_post: usize,
132 equations_with_lean: usize,
133 },
134 #[serde(rename = "reverse_coverage")]
135 ReverseCoverage {
136 total_pub_fns: usize,
137 bound_fns: usize,
138 unbound_fns: usize,
139 coverage_pct: f64,
140 threshold_pct: f64,
141 },
142 #[serde(rename = "composition")]
143 Composition {
144 edges_checked: usize,
145 edges_satisfied: usize,
146 edges_broken: usize,
147 },
148 #[serde(rename = "skipped")]
149 Skipped { reason: String },
150}
151
152#[derive(Debug, Clone, Serialize)]
155pub struct ShapesControls {
156 pub pc_extract: std::collections::BTreeMap<String, String>,
158 pub pc_shapes: std::collections::BTreeMap<String, String>,
161 #[serde(skip_serializing_if = "Option::is_none")]
164 pub capability_cells: Option<capability_cells_gate::CapabilityCellsReport>,
165 #[serde(skip_serializing_if = "Option::is_none")]
168 pub ggplot2_core: Option<ggplot2_core_gate::Ggplot2CoreReport>,
169}
170
171#[allow(clippy::large_enum_variant)]
195#[derive(Debug, Clone, Serialize)]
196#[serde(tag = "type")]
198#[non_exhaustive]
199pub enum GateExtra {
200 #[serde(rename = "duplicate_stems")]
202 DuplicateStems {
203 divergent: usize,
205 baselined: usize,
207 unbaselined: Vec<String>,
209 stale: Vec<String>,
211 divergent_stems: Vec<String>,
213 },
214 #[serde(rename = "sigma")]
216 Sigma {
217 entity_types: usize,
219 roles: usize,
221 symbols: usize,
223 contracts_checked: usize,
225 violations: usize,
227 formal_total: usize,
229 formal_prose: usize,
231 },
232 #[serde(rename = "relations")]
234 Relations {
235 relations_n: usize,
237 contracts_with_relations: usize,
239 roles_used: Vec<String>,
241 cycles: Vec<String>,
243 legacy_depends_on: usize,
245 legacy_unresolved_depends_on: usize,
247 violations: usize,
249 },
250 #[serde(rename = "evidence")]
252 Evidence {
253 contracts_checked: usize,
255 contracts_with_evidence: usize,
257 entity_types_checked: usize,
259 entity_types: Vec<String>,
261 levels_source: String,
263 by_level: Vec<String>,
265 census_git_sha: Option<String>,
267 unresolved_git_shas: usize,
269 violations: usize,
271 },
272 #[serde(rename = "valid_under")]
274 ValidUnder {
275 worlds: Vec<String>,
277 contracts_checked: usize,
279 kernel_contracts: usize,
281 contracts_with_valid_under: usize,
283 contracts_without_valid_under: usize,
285 baseline: Option<usize>,
287 by_world: Vec<String>,
289 violations: usize,
291 },
292 #[serde(rename = "theorem_pairing")]
294 TheoremPairing {
295 lean_base: String,
297 book_pages: usize,
299 theorem_modules: usize,
301 paired: usize,
303 unpaired_theorem_modules: usize,
305 baseline: Option<usize>,
307 unpaired: Vec<String>,
309 violations: usize,
311 },
312 #[serde(rename = "depends_on_present")]
314 DependsOnPresent {
315 contracts_checked: usize,
317 kernel_contracts: usize,
319 contracts_without_depends_on: usize,
321 baseline: Option<usize>,
323 violations: usize,
325 },
326 #[serde(rename = "references_resolve")]
328 ReferencesResolve {
329 contracts_checked: usize,
331 path_references: usize,
333 dead_references: usize,
335 baseline: Option<usize>,
337 dead: Vec<String>,
339 violations: usize,
341 },
342 #[serde(rename = "proved_is_derived")]
344 ProvedIsDerived {
345 summary: Option<String>,
347 summary_error: Option<String>,
349 summary_green: bool,
351 contracts_checked: usize,
353 proved_claims: usize,
355 underived_proved_claims: usize,
357 baseline: Option<usize>,
359 underived: Vec<String>,
361 violations: usize,
363 },
364 #[serde(rename = "challenge_fresh")]
366 ChallengeFresh {
367 lean_dir: String,
369 files: usize,
371 stale: Vec<String>,
373 unrestated: Vec<String>,
375 },
376 #[serde(rename = "shapes")]
378 Shapes {
379 shapes_n: usize,
381 focus_nodes_n: usize,
383 pc_shape: String,
385 plant_violations: usize,
387 violations: usize,
389 warnings: usize,
391 by_shape: Vec<String>,
393 triples: usize,
395 armed_shapes: Vec<String>,
397 not_armed_shapes: Vec<String>,
399 declines: Vec<String>,
420 unarmed_violations: usize,
422 by_entity_type: std::collections::BTreeMap<String, usize>,
424 #[serde(flatten)]
428 controls: Box<ShapesControls>,
429 receipts: usize,
431 witnesses: usize,
433 hex_mismatches: usize,
435 unmeasured_rows: usize,
437 w3c_cases_passed: usize,
439 w3c_cases_n: usize,
440 #[serde(flatten)]
444 counters: Box<ShapesCounters>,
445 #[serde(skip_serializing_if = "Option::is_none")]
447 release: Option<Box<crate::ontology::extract::release_evidence::ReleaseStats>>,
448 readme: MeasuredSet,
450 claude_md: MeasuredSet,
452 ratchets: Ratchets,
454 },
455 #[serde(rename = "ont_consistency")]
457 Consistency {
458 checkable_n: usize,
460 units: usize,
462 unencoded_edges: usize,
464 pc_checker: String,
466 core: Vec<String>,
468 violations: usize,
470 witness: consistency_gate::WitnessReport,
472 },
473 #[serde(rename = "refines")]
475 Refines(Box<refines_gate::RefinesCounters>),
476 #[serde(rename = "bindings")]
478 Bindings(Box<bindings_gate::BindingsCounters>),
479 #[serde(rename = "refinement")]
481 Refinement(Box<refinement_gate::RefinementCounters>),
482}
483
484#[derive(Debug, Clone, Default, Serialize)]
486pub struct ShapesCounters {
487 pub symbols_resolved: usize,
489 pub symbols_unresolved: usize,
490 pub lean_statements: usize,
492 pub lean_refs_unresolved: usize,
493 pub inherited_shapes_applied: usize,
498 pub inherited_by_shape: Vec<String>,
500}
501
502#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
504pub struct MeasuredSet {
505 pub verified_commands: Vec<String>,
506}
507
508#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
511pub struct Ratchets {
512 pub measured_sets: String,
513}
514
515impl Default for Ratchets {
516 fn default() -> Self {
517 Self {
518 measured_sets: "not-checked".into(),
519 }
520 }
521}
522
523#[derive(Debug, Clone, Serialize)]
525pub struct LintReport {
526 pub passed: bool,
527 pub gates: Vec<GateResult>,
528 pub total_duration_ms: u64,
529 #[serde(skip_serializing_if = "Vec::is_empty")]
530 pub findings: Vec<LintFinding>,
531 #[serde(skip)]
532 pub cache_stats: cache::CacheStats,
533 #[serde(default, skip_serializing_if = "Vec::is_empty")]
535 pub contract_timings: Vec<(String, u64)>,
536 pub verdict: Verdict,
539 pub armed_gates: Vec<ArmedGateVerdict>,
541 pub not_armed: Vec<String>,
543 #[serde(skip_serializing_if = "Option::is_none")]
545 pub armed_monotone: Option<String>,
546 #[serde(skip_serializing_if = "Option::is_none")]
548 pub armed_shapes_monotone: Option<String>,
549}
550
551#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
553pub struct ArmedGateVerdict {
554 pub name: String,
555 pub verdict: Verdict,
556}
557
558impl LintReport {
559 pub fn arm(&mut self, armed: &ArmedGates) {
561 let results: Vec<(String, Verdict)> = self
562 .gates
563 .iter()
564 .map(|g| (g.name.clone(), g.verdict))
565 .collect();
566 let meet = meet_armed(&results, armed);
567 self.verdict = meet.verdict;
568 self.armed_gates = meet
569 .armed
570 .into_iter()
571 .map(|(name, verdict)| ArmedGateVerdict { name, verdict })
572 .collect();
573 self.not_armed = meet.not_armed;
574 }
575}
576
577pub struct LintConfig<'a> {
579 pub contract_dir: &'a Path,
580 pub binding_path: Option<&'a Path>,
581 pub min_score: f64,
582 pub severity_filter: Option<RuleSeverity>,
583 pub severity_overrides: HashMap<String, RuleSeverity>,
584 pub suppressed_findings: Vec<String>,
585 pub suppressed_rules: Vec<String>,
586 pub suppressed_files: Vec<String>,
587 pub strict: bool,
588 pub no_cache: bool,
589 pub cache_stats: bool,
590 pub crate_dir: Option<&'a Path>,
592 pub min_level: Option<crate::schema::EnforcementLevel>,
594 pub strict_test_binding: bool,
596 pub strict_test_binding_only: bool,
600}
601
602impl<'a> LintConfig<'a> {
603 pub fn new(contract_dir: &'a Path, binding_path: Option<&'a Path>, min_score: f64) -> Self {
605 Self {
606 contract_dir,
607 binding_path,
608 min_score,
609 severity_filter: None,
610 severity_overrides: HashMap::new(),
611 suppressed_findings: Vec::new(),
612 suppressed_rules: Vec::new(),
613 suppressed_files: Vec::new(),
614 strict: false,
615 no_cache: false,
616 cache_stats: false,
617 crate_dir: None,
618 min_level: None,
619 strict_test_binding: false,
620 strict_test_binding_only: false,
621 }
622 }
623}
624
625fn push_gate<F>(
630 gates: &mut Vec<GateResult>,
631 all_findings: &mut Vec<LintFinding>,
632 run: F,
633 name: &str,
634 validation_passed: bool,
635) where
636 F: FnOnce() -> (GateResult, Vec<LintFinding>),
637{
638 let (result, mut findings) = if validation_passed {
639 run()
640 } else {
641 (skipped_gate(name, "validation failed"), Vec::new())
642 };
643 gates.push(result);
644 all_findings.append(&mut findings);
645}
646
647fn per_contract_timings(
650 contracts: &[(String, crate::schema::Contract)],
651 binding: Option<&crate::binding::BindingRegistry>,
652) -> Vec<(String, u64)> {
653 let mut contract_timings: Vec<(String, u64)> = Vec::with_capacity(contracts.len());
654 for (stem, contract) in contracts {
655 let ct_start = Instant::now();
656 let _ = crate::schema::validate_contract(contract);
658 let _ = crate::audit::audit_contract(contract);
660 let _ = crate::scoring::score_contract(contract, binding, stem);
662 let ct_ms = u64::try_from(ct_start.elapsed().as_micros() / 1000).unwrap_or(0);
663 contract_timings.push((format!("{stem}.yaml"), ct_ms));
664 }
665 contract_timings.sort_by_key(|b| std::cmp::Reverse(b.1));
667 contract_timings
668}
669
670fn store_findings_in_cache(
672 root: &std::path::Path,
673 config: &LintConfig,
674 contracts: &[(String, crate::schema::Contract)],
675 all_findings: &[LintFinding],
676 stats: &mut cache::CacheStats,
677) {
678 let rule_cfg = format!("{:?}{:?}", config.severity_overrides, config.strict);
679 for (stem, _) in contracts {
680 stats.total += 1;
681 let yaml_path = config.contract_dir.join(format!("{stem}.yaml"));
682 let yaml_content = std::fs::read_to_string(&yaml_path).unwrap_or_default();
683 let hash = cache::content_hash(&yaml_content, &rule_cfg);
684 if cache::cache_get(root, &hash).is_some() {
685 stats.hits += 1;
686 } else {
687 stats.misses += 1;
688 let contract_findings: Vec<_> = all_findings
689 .iter()
690 .filter(|f| f.contract_stem.as_deref() == Some(stem.as_str()))
691 .cloned()
692 .collect();
693 let _ = cache::cache_put(root, &hash, &contract_findings);
694 }
695 }
696}
697
698fn run_gates_2_to_9(
701 config: &LintConfig,
702 contracts: &[(String, crate::schema::Contract)],
703 binding: Option<&crate::binding::BindingRegistry>,
704 validation_passed: bool,
705 gates: &mut Vec<GateResult>,
706 all_findings: &mut Vec<LintFinding>,
707) {
708 push_gate(
710 gates,
711 all_findings,
712 || run_audit_gate(contracts),
713 "audit",
714 validation_passed,
715 );
716
717 push_gate(
719 gates,
720 all_findings,
721 || run_score_gate(contracts, binding, config.min_score),
722 "score",
723 validation_passed,
724 );
725
726 push_gate(
728 gates,
729 all_findings,
730 || {
731 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
732 run_verify_gate(contracts, project_root)
733 },
734 "verify",
735 validation_passed,
736 );
737
738 push_gate(
740 gates,
741 all_findings,
742 || run_enforce_gate(contracts),
743 "enforce",
744 validation_passed,
745 );
746
747 push_gate(
749 gates,
750 all_findings,
751 || {
752 let min_level = config
753 .min_level
754 .unwrap_or(crate::schema::EnforcementLevel::Standard);
755 run_enforcement_level_gate(contracts, min_level)
756 },
757 "enforcement-level",
758 validation_passed,
759 );
760
761 push_gate(
763 gates,
764 all_findings,
765 || match (config.binding_path, config.crate_dir) {
766 (Some(bp), Some(cd)) => run_reverse_coverage_gate(bp, cd),
767 _ => (
768 skipped_gate("reverse-coverage", "no --binding or --crate-dir provided"),
769 Vec::new(),
770 ),
771 },
772 "reverse-coverage",
773 validation_passed,
774 );
775
776 let duplicates = duplicate_stems::scan_duplicate_stems(config.contract_dir);
780 let ambiguous = duplicate_stems::ambiguous_stems(&duplicates);
781 push_gate(
782 gates,
783 all_findings,
784 || {
785 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
786 let baseline = duplicate_stems::read_baseline(project_root);
787 duplicate_stems::run_duplicate_stem_gate(&duplicates, &baseline)
788 },
789 "duplicate-stems",
790 validation_passed,
791 );
792
793 push_gate(
795 gates,
796 all_findings,
797 || composition_gate::run_composition_gate(contracts, &ambiguous),
798 "composition",
799 validation_passed,
800 );
801}
802
803fn run_ontology_gates_10_to_22(
806 contract_dir: &Path,
807 validation_passed: bool,
808 gates: &mut Vec<GateResult>,
809 all_findings: &mut Vec<LintFinding>,
810) {
811 let (sigma_gate_result, mut sigma_findings) = sigma_result(contract_dir, validation_passed);
814 gates.push(sigma_gate_result);
815 all_findings.append(&mut sigma_findings);
816
817 let (relations_gate_result, mut relations_findings) =
819 relations_result(contract_dir, validation_passed);
820 gates.push(relations_gate_result);
821 all_findings.append(&mut relations_findings);
822
823 let (shapes_gate_result, mut shapes_findings) = shapes_result(contract_dir, validation_passed);
825 gates.push(shapes_gate_result);
826 all_findings.append(&mut shapes_findings);
827
828 let (valid_under_gate_result, mut valid_under_findings) =
830 valid_under_result(contract_dir, validation_passed);
831 gates.push(valid_under_gate_result);
832 all_findings.append(&mut valid_under_findings);
833
834 for (name, run) in RATCHET_GATES {
837 let (result, mut findings) = ratchet_result(contract_dir, validation_passed, name, run);
838 gates.push(result);
839 all_findings.append(&mut findings);
840 }
841
842 gates.push(challenge_result(contract_dir));
845
846 let (consistency_gate_result, mut consistency_findings) =
849 consistency_result(contract_dir, validation_passed);
850 gates.push(consistency_gate_result);
851 all_findings.append(&mut consistency_findings);
852
853 let (refines_gate_result, mut refines_findings) =
855 refines_result(contract_dir, validation_passed);
856 gates.push(refines_gate_result);
857 all_findings.append(&mut refines_findings);
858
859 let (bindings_gate_result, mut bindings_findings) = ratchet_result(
861 contract_dir,
862 validation_passed,
863 bindings_gate::GATE,
864 bindings_gate::run_bindings_gate,
865 );
866 gates.push(bindings_gate_result);
867 all_findings.append(&mut bindings_findings);
868
869 let (refinement_gate_result, mut refinement_findings) = ratchet_result(
871 contract_dir,
872 validation_passed,
873 refinement_gate::GATE,
874 refinement_gate::run_refinement_gate,
875 );
876 gates.push(refinement_gate_result);
877 all_findings.append(&mut refinement_findings);
878
879 let (evidence_gate_result, mut evidence_findings) =
881 evidence_result(contract_dir, validation_passed);
882 gates.push(evidence_gate_result);
883 all_findings.append(&mut evidence_findings);
884}
885
886fn run_strict_test_binding_gate_if_enabled(
888 config: &LintConfig,
889 contracts: &[(String, crate::schema::Contract)],
890 validation_passed: bool,
891 gates: &mut Vec<GateResult>,
892 all_findings: &mut Vec<LintFinding>,
893) {
894 if !config.strict_test_binding {
895 return;
896 }
897 push_gate(
898 gates,
899 all_findings,
900 || {
901 let project_root = config.contract_dir.parent().unwrap_or(config.contract_dir);
902 strict_test_binding::run_strict_test_binding_gate(
903 contracts,
904 project_root,
905 config.strict,
906 )
907 },
908 "strict-test-binding",
909 validation_passed,
910 );
911}
912
913#[allow(clippy::too_many_arguments)]
916fn finalize_findings(
917 config: &LintConfig,
918 contracts: &[(String, crate::schema::Contract)],
919 binding: Option<&crate::binding::BindingRegistry>,
920 validation_passed: bool,
921 cache_root: Option<&std::path::Path>,
922 stats: &mut cache::CacheStats,
923 all_findings: &mut Vec<LintFinding>,
924 mut validate_findings: Vec<LintFinding>,
925) -> Vec<(String, u64)> {
926 all_findings.append(&mut validate_findings);
927
928 let contract_timings = if validation_passed {
930 per_contract_timings(contracts, binding)
931 } else {
932 Vec::new()
933 };
934
935 let mut stale_findings = check_stale_suppressions(
937 all_findings,
938 &config.suppressed_rules,
939 &config.suppressed_findings,
940 );
941 all_findings.append(&mut stale_findings);
942
943 mark_new_findings(all_findings, config.contract_dir);
945
946 if let Some(root) = cache_root {
948 store_findings_in_cache(root, config, contracts, all_findings, stats);
949 }
950
951 apply_suppressions(all_findings, config);
953 apply_severity_overrides(all_findings, config);
954 if let Some(min_sev) = config.severity_filter {
955 all_findings.retain(|f| f.severity >= min_sev);
956 }
957
958 contract_timings
959}
960
961pub fn run_lint(config: &LintConfig) -> LintReport {
963 let overall_start = Instant::now();
964 let mut gates = Vec::with_capacity(3);
965 let mut all_findings = Vec::new();
966 let mut stats = cache::CacheStats::default();
967
968 let cache_root = if config.no_cache || config.strict_test_binding_only {
970 None
971 } else {
972 Some(cache::cache_dir(config.contract_dir))
973 };
974
975 let (contracts, parse_errors) = load_contracts(config.contract_dir);
976 let binding = load_binding(config.binding_path);
977
978 let (validate_result, validate_findings) = run_validate_gate(&contracts, &parse_errors);
980 let validation_passed = validate_result.passed;
981 gates.push(validate_result);
982
983 if !config.strict_test_binding_only {
984 run_gates_2_to_9(
985 config,
986 &contracts,
987 binding.as_ref(),
988 validation_passed,
989 &mut gates,
990 &mut all_findings,
991 );
992 run_ontology_gates_10_to_22(
993 config.contract_dir,
994 validation_passed,
995 &mut gates,
996 &mut all_findings,
997 );
998 }
999 run_strict_test_binding_gate_if_enabled(
1000 config,
1001 &contracts,
1002 validation_passed,
1003 &mut gates,
1004 &mut all_findings,
1005 );
1006
1007 let contract_timings = finalize_findings(
1008 config,
1009 &contracts,
1010 binding.as_ref(),
1011 validation_passed,
1012 cache_root.as_deref(),
1013 &mut stats,
1014 &mut all_findings,
1015 validate_findings,
1016 );
1017
1018 let passed = gates.iter().all(|g| g.passed || g.skipped);
1019
1020 let mut report = LintReport {
1021 passed,
1022 gates,
1023 total_duration_ms: u64::try_from(overall_start.elapsed().as_millis()).unwrap_or(u64::MAX),
1024 findings: all_findings,
1025 cache_stats: stats,
1026 contract_timings,
1027 verdict: Verdict::Unknown(crate::ontology::verdict::Reason::NotArmed),
1028 armed_gates: Vec::new(),
1029 not_armed: Vec::new(),
1030 armed_monotone: None,
1031 armed_shapes_monotone: None,
1032 };
1033 report.arm(&ArmedGates::default_set());
1036 report
1037}
1038
1039pub enum NamedGateOutcome {
1041 UnknownGate,
1043 Sigma(sigma_gate::SigmaOutcome),
1045 Relations(relations_gate::RelationsOutcome),
1047 Shapes(shapes_gate::ShapesOutcome),
1049 Consistency(consistency_gate::ConsistencyOutcome),
1051 Refines(refines_gate::RefinesOutcome),
1053 Tbox(tbox_gate::TboxOutcome),
1055 Evidence(evidence_gate::EvidenceOutcome),
1057 ValidUnder(valid_under_gate::ValidUnderOutcome),
1059 Ratchet(ratchet_gates::RatchetOutcome),
1061 Ran {
1063 result: Box<GateResult>,
1064 findings: Vec<LintFinding>,
1065 },
1066}
1067
1068#[must_use]
1074pub fn run_named_gate(contract_dir: &Path, name: &str) -> NamedGateOutcome {
1075 run_named_gate_with(contract_dir, name, &shapes_gate::ShapesOptions::default())
1076}
1077
1078pub fn run_named_gate_with(
1080 contract_dir: &Path,
1081 name: &str,
1082 shapes_opts: &shapes_gate::ShapesOptions,
1083) -> NamedGateOutcome {
1084 match name {
1085 "evidence" => NamedGateOutcome::Evidence(evidence_gate::run_evidence_gate(contract_dir)),
1086 "relations" => {
1087 NamedGateOutcome::Relations(relations_gate::run_relations_gate(contract_dir))
1088 }
1089 "shapes" => {
1090 NamedGateOutcome::Shapes(shapes_gate::run_shapes_gate_with(contract_dir, shapes_opts))
1091 }
1092 "sigma" => NamedGateOutcome::Sigma(sigma_gate::run_sigma_gate(contract_dir)),
1093 consistency_gate::GATE => {
1094 NamedGateOutcome::Consistency(consistency_gate::run_consistency_gate(contract_dir))
1095 }
1096 refines_gate::GATE => {
1097 NamedGateOutcome::Refines(refines_gate::run_refines_gate(contract_dir))
1098 }
1099 bindings_gate::GATE => {
1100 NamedGateOutcome::Ratchet(bindings_gate::run_bindings_gate(contract_dir))
1101 }
1102 refinement_gate::GATE => {
1103 NamedGateOutcome::Ratchet(refinement_gate::run_refinement_gate(contract_dir))
1104 }
1105 "tbox" => NamedGateOutcome::Tbox(tbox_gate::run_tbox_gate(contract_dir)),
1106 "valid-under" => {
1107 NamedGateOutcome::ValidUnder(valid_under_gate::run_valid_under_gate(contract_dir))
1108 }
1109 "theorem-pairing" => {
1110 NamedGateOutcome::Ratchet(ratchet_gates::run_theorem_pairing_gate(contract_dir))
1111 }
1112 "depends-on-present" => {
1113 NamedGateOutcome::Ratchet(ratchet_gates::run_depends_on_present_gate(contract_dir))
1114 }
1115 references_gate::GATE => {
1116 NamedGateOutcome::Ratchet(references_gate::run_references_gate(contract_dir))
1117 }
1118 "proved-is-derived" => {
1119 NamedGateOutcome::Ratchet(ratchet_gates::run_proved_is_derived_gate(contract_dir))
1120 }
1121 "validate" => {
1122 let (contracts, parse_errors) = load_contracts(contract_dir);
1123 let (result, findings) = run_validate_gate(&contracts, &parse_errors);
1124 NamedGateOutcome::Ran {
1125 result: Box::new(result),
1126 findings,
1127 }
1128 }
1129 _ => NamedGateOutcome::UnknownGate,
1130 }
1131}
1132
1133pub const NAMED_GATES: [&str; 15] = [
1135 references_gate::GATE,
1136 bindings_gate::GATE,
1137 refinement_gate::GATE,
1138 "depends-on-present",
1139 "evidence",
1140 consistency_gate::GATE,
1141 "proved-is-derived",
1142 refines_gate::GATE,
1143 "relations",
1144 "shapes",
1145 "sigma",
1146 "tbox",
1147 "theorem-pairing",
1148 "valid-under",
1149 "validate",
1150];
1151
1152type RatchetRun = fn(&Path) -> ratchet_gates::RatchetOutcome;
1154const RATCHET_GATES: [(&str, RatchetRun); 4] = [
1155 ("theorem-pairing", ratchet_gates::run_theorem_pairing_gate),
1156 (
1157 "depends-on-present",
1158 ratchet_gates::run_depends_on_present_gate,
1159 ),
1160 (
1161 "proved-is-derived",
1162 ratchet_gates::run_proved_is_derived_gate,
1163 ),
1164 (references_gate::GATE, references_gate::run_references_gate),
1165];
1166
1167fn ratchet_result(
1170 contract_dir: &Path,
1171 validation_passed: bool,
1172 name: &str,
1173 run: RatchetRun,
1174) -> (GateResult, Vec<LintFinding>) {
1175 if !validation_passed {
1176 return (skipped_gate(name, "validation failed"), Vec::new());
1177 }
1178 match run(contract_dir) {
1179 ratchet_gates::RatchetOutcome::Ran { result, findings } => (*result, findings),
1180 ratchet_gates::RatchetOutcome::Declined(why) => (skipped_gate(name, &why), Vec::new()),
1181 }
1182}
1183
1184fn sigma_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1188 if !validation_passed {
1189 return (skipped_gate("sigma", "validation failed"), Vec::new());
1190 }
1191 match sigma_gate::run_sigma_gate(contract_dir) {
1192 sigma_gate::SigmaOutcome::Ran { result, findings } => (*result, findings),
1193 sigma_gate::SigmaOutcome::NoSigma => (
1194 skipped_gate("sigma", "no contracts/ontology.yaml"),
1195 Vec::new(),
1196 ),
1197 sigma_gate::SigmaOutcome::Malformed(e) => (
1198 skipped_gate("sigma", &format!("Σ is malformed: {e}")),
1199 Vec::new(),
1200 ),
1201 }
1202}
1203
1204fn evidence_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1207 if !validation_passed {
1208 return (skipped_gate("evidence", "validation failed"), Vec::new());
1209 }
1210 match evidence_gate::run_evidence_gate(contract_dir) {
1211 evidence_gate::EvidenceOutcome::Ran { result, findings } => (*result, findings),
1212 evidence_gate::EvidenceOutcome::NoSigma => (
1213 skipped_gate("evidence", "no contracts/ontology.yaml"),
1214 Vec::new(),
1215 ),
1216 evidence_gate::EvidenceOutcome::Malformed(e) => (
1217 skipped_gate("evidence", &format!("Σ is malformed: {e}")),
1218 Vec::new(),
1219 ),
1220 evidence_gate::EvidenceOutcome::NoEvidence { contracts_checked } => (
1221 skipped_gate(
1222 "evidence",
1223 &format!(
1224 "no evidence block in {contracts_checked} contracts — R-2: zero is a decline"
1225 ),
1226 ),
1227 Vec::new(),
1228 ),
1229 }
1230}
1231
1232fn valid_under_result(
1235 contract_dir: &Path,
1236 validation_passed: bool,
1237) -> (GateResult, Vec<LintFinding>) {
1238 if !validation_passed {
1239 return (skipped_gate("valid-under", "validation failed"), Vec::new());
1240 }
1241 match valid_under_gate::run_valid_under_gate(contract_dir) {
1242 valid_under_gate::ValidUnderOutcome::Ran { result, findings } => (*result, findings),
1243 valid_under_gate::ValidUnderOutcome::NoSigma => (
1244 skipped_gate("valid-under", "no contracts/ontology.yaml"),
1245 Vec::new(),
1246 ),
1247 valid_under_gate::ValidUnderOutcome::Malformed(e) => (
1248 skipped_gate("valid-under", &format!("Σ is malformed: {e}")),
1249 Vec::new(),
1250 ),
1251 valid_under_gate::ValidUnderOutcome::NoKernels { contracts_checked } => (
1252 skipped_gate(
1253 "valid-under",
1254 &format!("no kernel-kind contract and no valid_under in {contracts_checked} contracts — R-2: zero is a decline"),
1255 ),
1256 Vec::new(),
1257 ),
1258 }
1259}
1260
1261fn relations_result(
1264 contract_dir: &Path,
1265 validation_passed: bool,
1266) -> (GateResult, Vec<LintFinding>) {
1267 if !validation_passed {
1268 return (skipped_gate("relations", "validation failed"), Vec::new());
1269 }
1270 match relations_gate::run_relations_gate(contract_dir) {
1271 relations_gate::RelationsOutcome::Ran { result, findings } => (*result, findings),
1272 relations_gate::RelationsOutcome::NoSigma => (
1273 skipped_gate("relations", "no contracts/ontology.yaml"),
1274 Vec::new(),
1275 ),
1276 relations_gate::RelationsOutcome::Malformed(e) => (
1277 skipped_gate("relations", &format!("Σ is malformed: {e}")),
1278 Vec::new(),
1279 ),
1280 relations_gate::RelationsOutcome::NoRelations {
1281 contracts_checked,
1282 legacy_depends_on,
1283 } => (
1284 skipped_gate(
1285 "relations",
1286 &format!("no typed relations in {contracts_checked} contracts ({legacy_depends_on} legacy metadata.depends_on edges) — R-2: zero is a decline"),
1287 ),
1288 Vec::new(),
1289 ),
1290 }
1291}
1292
1293fn shapes_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1296 if !validation_passed {
1297 return (skipped_gate("shapes", "validation failed"), Vec::new());
1298 }
1299 match shapes_gate::run_shapes_gate(contract_dir) {
1300 shapes_gate::ShapesOutcome::Ran { result, findings } => (*result, findings),
1301 shapes_gate::ShapesOutcome::Unsupported(e) => (skipped_gate("shapes", &format!("{e}")), Vec::new()),
1302 shapes_gate::ShapesOutcome::ExtractFailed(e) => (skipped_gate("shapes", &format!("{e}")), Vec::new()),
1303 shapes_gate::ShapesOutcome::NoShapes { contracts_checked } => (
1304 skipped_gate("shapes", &format!("no `shape:` block in {contracts_checked} contracts — R-2: zero is a decline")),
1305 Vec::new(),
1306 ),
1307 shapes_gate::ShapesOutcome::NoFocus { shapes_n } => (
1308 skipped_gate("shapes", &format!("{shapes_n} shape(s), no focus node")),
1309 Vec::new(),
1310 ),
1311 shapes_gate::ShapesOutcome::WrongCorpus { shapes_n, expected, found, refused } => (
1312 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("; ")) })),
1313 Vec::new(),
1314 ),
1315 shapes_gate::ShapesOutcome::HarnessBroken { causes } => (
1316 skipped_gate("shapes", &format!("the CRUX harness measured itself, not apr: {}", causes.join("; "))),
1317 Vec::new(),
1318 ),
1319 shapes_gate::ShapesOutcome::NoReceipts { shapes_n, dir } => (
1320 skipped_gate("shapes", &format!("{shapes_n} shape(s) resolve receipts and the tree holds none under {dir}/ — R-2: unmeasured is a decline")),
1321 Vec::new(),
1322 ),
1323 shapes_gate::ShapesOutcome::EmptyDomain { shapes_n } => (
1324 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")),
1325 Vec::new(),
1326 ),
1327 shapes_gate::ShapesOutcome::PositiveControlFailed { shapes_n, focus_nodes_n, which } => (
1328 skipped_gate("shapes", &format!("positive control {which} did not fire ({shapes_n} shape(s), {focus_nodes_n} focus node(s)) — the gate cannot reject")),
1329 Vec::new(),
1330 ),
1331 shapes_gate::ShapesOutcome::Differential { shapes_n, focus_nodes_n, passed, n, failed } => {
1332 let mut g = skipped_gate(
1333 "shapes",
1334 &format!(
1335 "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",
1336 failed.join(" | ")
1337 ),
1338 );
1339 g.verdict = Verdict::Unknown(crate::ontology::verdict::Reason::Differential);
1340 (g, Vec::new())
1341 }
1342 }
1343}
1344
1345fn consistency_result(
1348 contract_dir: &Path,
1349 validation_passed: bool,
1350) -> (GateResult, Vec<LintFinding>) {
1351 if !validation_passed {
1352 return (
1353 skipped_gate(consistency_gate::GATE, "validation failed"),
1354 Vec::new(),
1355 );
1356 }
1357 let outcome = consistency_gate::run_consistency_gate(contract_dir);
1358 if let consistency_gate::ConsistencyOutcome::Ran { result, findings } = outcome {
1359 return (*result, findings);
1360 }
1361 let mut g = skipped_gate(consistency_gate::GATE, &consistency_gate::why(&outcome));
1362 if let Some(reason) = consistency_gate::decline_reason(&outcome) {
1363 g.verdict = Verdict::Unknown(reason);
1364 }
1365 (g, Vec::new())
1366}
1367
1368fn refines_result(contract_dir: &Path, validation_passed: bool) -> (GateResult, Vec<LintFinding>) {
1370 if !validation_passed {
1371 return (
1372 skipped_gate(refines_gate::GATE, "validation failed"),
1373 Vec::new(),
1374 );
1375 }
1376 let outcome = refines_gate::run_refines_gate(contract_dir);
1377 if let refines_gate::RefinesOutcome::Ran { result, findings } = outcome {
1378 return (*result, findings);
1379 }
1380 let mut g = skipped_gate(refines_gate::GATE, &refines_gate::why(&outcome));
1381 if let Some(reason) = refines_gate::decline_reason(&outcome) {
1382 g.verdict = Verdict::Unknown(reason);
1383 }
1384 (g, Vec::new())
1385}
1386
1387fn challenge_result(contract_dir: &Path) -> GateResult {
1390 const NAME: &str = "challenge-fresh";
1391 let start = Instant::now();
1392 let root = crate::ontology::extract::repo_root(contract_dir);
1393 let Some(lean) = crate::ontology::extract::lean::base_under(&root) else {
1394 return skipped_gate(NAME, "no Lean theorem base under the repo root");
1395 };
1396 let r = match crate::discharge::challenge::render(&lean, contract_dir) {
1397 Ok(r) => r,
1398 Err(e) => return skipped_gate(NAME, &format!("the Lean tree does not load: {e}")),
1399 };
1400 if r.files.is_empty() && r.unrestated.is_empty() {
1401 return skipped_gate(
1402 NAME,
1403 "zero challenges: no contract binds a theorem — R-2: zero is a decline",
1404 );
1405 }
1406 let stale = crate::discharge::challenge::diff(&lean, &r);
1407 let unrestated: Vec<String> = r
1408 .unrestated
1409 .iter()
1410 .map(|(c, fqn, why)| format!("{c}: {fqn}: {why}"))
1411 .collect();
1412 let passed = stale.is_empty() && unrestated.is_empty();
1413 GateResult {
1414 name: NAME.into(),
1415 passed,
1416 skipped: false,
1417 verdict: Verdict::from_gate(passed, false),
1418 duration_ms: u64::try_from(start.elapsed().as_millis()).unwrap_or(u64::MAX),
1419 detail: GateDetail::Validate {
1421 contracts: r.files.len(),
1422 errors: stale.len() + unrestated.len(),
1423 warnings: 0,
1424 error_messages: stale.iter().chain(&unrestated).cloned().collect(),
1425 },
1426 extra: Some(GateExtra::ChallengeFresh {
1427 lean_dir: lean.display().to_string(),
1428 files: r.files.len(),
1429 stale,
1430 unrestated,
1431 }),
1432 }
1433}
1434
1435fn skipped_gate(name: &str, reason: &str) -> GateResult {
1436 GateResult {
1437 name: name.into(),
1438 passed: false,
1439 skipped: true,
1440 verdict: Verdict::from_gate(false, true),
1441 duration_ms: 0,
1442 detail: GateDetail::Skipped {
1443 reason: reason.into(),
1444 },
1445 extra: None,
1446 }
1447}
1448
1449fn apply_suppressions(findings: &mut [LintFinding], config: &LintConfig) {
1450 for f in findings.iter_mut() {
1451 if config.suppressed_rules.iter().any(|r| r == &f.rule_id) {
1452 f.suppressed = true;
1453 f.suppression_reason = Some("Suppressed by --suppress-rule".into());
1454 }
1455 if let Some(ref stem) = f.contract_stem {
1456 if config.suppressed_findings.iter().any(|s| s == stem) {
1457 f.suppressed = true;
1458 f.suppression_reason = Some("Suppressed by --suppress".into());
1459 }
1460 }
1461 if config.suppressed_files.iter().any(|p| f.file.contains(p)) {
1462 f.suppressed = true;
1463 f.suppression_reason = Some("Suppressed by --suppress-file".into());
1464 }
1465 }
1466}
1467
1468fn pv_state_dir(contract_dir: &Path) -> std::path::PathBuf {
1470 contract_dir.parent().unwrap_or(contract_dir).join(".pv")
1471}
1472
1473fn mark_new_findings(findings: &mut [LintFinding], contract_dir: &Path) {
1476 let state_dir = pv_state_dir(contract_dir);
1477 let previous_path = state_dir.join("lint-previous.json");
1478
1479 let previous: HashSet<String> = std::fs::read_to_string(&previous_path)
1481 .ok()
1482 .and_then(|s| serde_json::from_str(&s).ok())
1483 .unwrap_or_default();
1484
1485 let mut current = HashSet::new();
1487 for f in findings.iter_mut() {
1488 let fp = f.fingerprint();
1489 if !previous.contains(&fp) {
1490 f.is_new = true;
1491 }
1492 current.insert(fp);
1493 }
1494
1495 if let Err(e) = std::fs::create_dir_all(&state_dir) {
1497 eprintln!("pv lint: cannot create {}: {e}", state_dir.display());
1498 return;
1499 }
1500 if let Ok(json) = serde_json::to_string(¤t) {
1501 let _ = std::fs::write(&previous_path, json);
1502 }
1503}
1504
1505fn apply_severity_overrides(findings: &mut [LintFinding], config: &LintConfig) {
1506 for f in findings.iter_mut() {
1507 if let Some(&sev) = config.severity_overrides.get(&f.rule_id) {
1508 f.severity = sev;
1509 }
1510 }
1511 if config.strict {
1512 for f in findings.iter_mut() {
1513 if f.severity == RuleSeverity::Warning {
1514 f.severity = RuleSeverity::Error;
1515 }
1516 }
1517 }
1518}
1519
1520#[cfg(test)]
1521#[path = "mod_tests.rs"]
1522mod tests;