Skip to main content

mimir_node_map/
position.rs

1// SPDX-License-Identifier: MIT OR Apache-2.0
2//! Structural position classification shared by producer and consumer.
3use crate::{HoleHow, HoleNode, proof::ProofKind as P};
4use std::collections::BTreeSet;
5
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub enum HolePosition {
8    Unproven,
9    Required,
10    Absent,
11    Optional,
12}
13
14/// File pins, target-set evidence and binary/table correspondence must also be
15/// validated by the caller. Neither `required` nor `quiet` establishes a proof.
16pub fn hole(row: &HoleNode) -> HolePosition {
17    use HolePosition::*;
18    let proof = row.proof.as_deref().and_then(P::parse);
19    if proof == Some(P::HoleInlined) {
20        return row.inline_binding.as_ref().map_or(Unproven, |b| {
21            let identity = crate::InlineRow {
22                site: b.site,
23                node: b.node.clone(),
24                instance: b.instance.clone(),
25                position: b.position.clone(),
26                kind: b.kind.clone(),
27                targets: b.targets.clone(),
28                numbers_known: false,
29            };
30            if crate::inline::check_hole(row, &identity).is_ok() {
31                Absent
32            } else {
33                Unproven
34            }
35        });
36    }
37    if row.why.is_some()
38        || !matches!(
39            proof,
40            Some(P::Hole | P::HoleDirect | P::HoleSite | P::HoleReport | P::HoleMerged)
41        )
42    {
43        return Unproven;
44    }
45    let addresses: BTreeSet<_> = row.addresses.iter().copied().collect();
46    if addresses.len() != row.addresses.len() || addresses.contains(&0) {
47        return Unproven;
48    }
49    if proof == Some(P::HoleMerged) {
50        if row.merged.is_empty() || !addresses.is_empty() || !row.direct.is_empty() {
51            return Unproven;
52        }
53    } else if addresses.is_empty() {
54        return Unproven;
55    }
56    let direct: BTreeSet<_> = row.direct.iter().map(|d| d.address).collect();
57    if direct.len() != row.direct.len()
58        || !direct.is_subset(&addresses)
59        || row
60            .direct
61            .iter()
62            .any(|d| d.target == 0 || d.symbol.is_empty())
63        || (proof == Some(P::HoleDirect) && direct.is_empty())
64        || (matches!(proof, Some(P::Hole | P::HoleReport)) && !direct.is_empty())
65        || (proof == Some(P::HoleReport) && row.how != Some(HoleHow::Call))
66    {
67        return Unproven;
68    }
69    match row.how {
70        Some(HoleHow::Call | HoleHow::Devirtualized) => {
71            if row.return_site.is_none()
72                || row.return_node.as_ref().is_none_or(String::is_empty)
73                || row.return_proof.as_deref().and_then(P::parse) != Some(P::HoleReturn)
74                || row.return_why.is_some()
75                || row.addresses.len() != row.continuations.len()
76            {
77                return Unproven;
78            }
79        }
80        Some(HoleHow::TailJump) => {
81            if row.return_site.is_some()
82                || row.return_node.is_some()
83                || !row.continuations.is_empty()
84            {
85                return Unproven;
86            }
87        }
88        _ => return Unproven,
89    }
90    if row.how == Some(HoleHow::Devirtualized) && direct != addresses {
91        return Unproven;
92    }
93    if direct.is_empty() {
94        return Required;
95    }
96    // A missing observed copy is not optimizer-removal evidence.
97    if row.copies == 0 || row.copies != row.copies_with_call {
98        return Unproven;
99    }
100    if direct == addresses && row.merged.is_empty() {
101        Absent
102    } else {
103        Optional
104    }
105}