Struct Reachability 

pub struct Reachability {
    pub verdict: ReachVerdict,
    pub config: String,
    pub engine: String,
    pub targets: Vec<String>,
    pub witness: Option<String>,
}

A static-reachability verdict for a finding’s affected functions, scoped to the toolchain + feature/target config it was computed under (spec §7).

Fields

verdict: ReachVerdict

The reachability outcome for the finding’s affected functions.

config: String

The config the verdict is scoped to (toolchain + features/target).

engine: String

The engine that produced it, e.g. static-mir-rta@<ver>.

targets: Vec<String>

The target triple(s) the verdict was computed for (spec §7 edge 3): a function unreachable on one target may be reachable behind a cfg on another, so a NotReachable names its targets. Additive; omitted when empty.

witness: Option<String>

A content-addressed witness for a NotReachable verdict (spec §9.2): a hash binding the verdict to the exact inputs that produced it (lockfile, source, toolchain, features, sinks). fleetreach vex verify re-derives against current source and fails if the verdict no longer holds. Additive; None for Reachable/Unknown and when caching was impossible.

Implementations

impl Reachability

pub fn tier_c_unknown(reason: impl Into<String>) -> Self

The reachability verdict shared by every toolchain-free (Tier-C) feeder: a package/version match with no call-graph analysis. It is always Unknown (never NotReachable — Tier-C must not claim a soundness it did not compute), with a fixed config/engine so the report renders the tier consistently across all ecosystems. reason names the lower fidelity for the report.

Centralizing this here keeps the Tier-C contract in one place instead of copy-pasted into each feeder’s scan.rs, where a divergence would be a silent per-ecosystem inconsistency the compiler could not catch.

pub fn as_legacy_bool(&self) -> Option<bool>

Map onto the legacy heuristic reachable: Option<bool> for back-compat (spec §7): Reachable -> Some(true), NotReachable -> Some(false), Unknown -> None.

Trait Implementations

impl Clone for Reachability

fn clone(&self) -> Reachability

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Reachability

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Reachability

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Reachability

fn eq(&self, other: &Reachability) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Reachability

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Reachability