xbp-analysis 10.57.0

Language-agnostic static analysis (error-handling / Aspirator-style) for XBP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! Explicit language adapter capabilities.

use serde::{Deserialize, Serialize};
use std::collections::BTreeSet;

/// Capabilities a language adapter may provide.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Capability {
    Ast,
    TypeInfo,
    ControlFlowGraph,
    ErrorFlow,
    CallSites,
    ExceptionOrResult,
    MacroAwareness,
    SourceRewrite,
    AsyncConcurrency,
    GeneratedCodeAwareness,
}

impl Capability {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Ast => "ast",
            Self::TypeInfo => "type_info",
            Self::ControlFlowGraph => "control_flow_graph",
            Self::ErrorFlow => "error_flow",
            Self::CallSites => "call_sites",
            Self::ExceptionOrResult => "exception_or_result",
            Self::MacroAwareness => "macro_awareness",
            Self::SourceRewrite => "source_rewrite",
            Self::AsyncConcurrency => "async_concurrency",
            Self::GeneratedCodeAwareness => "generated_code_awareness",
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct CapabilitySet {
    pub caps: BTreeSet<Capability>,
}

impl CapabilitySet {
    pub fn new(caps: impl IntoIterator<Item = Capability>) -> Self {
        Self {
            caps: caps.into_iter().collect(),
        }
    }

    pub fn contains(&self, c: Capability) -> bool {
        self.caps.contains(&c)
    }

    pub fn is_superset_of(&self, required: &CapabilitySet) -> bool {
        required.caps.is_subset(&self.caps)
    }

    pub fn rust_syn_default() -> Self {
        Self::new([
            Capability::Ast,
            Capability::ErrorFlow,
            Capability::CallSites,
            Capability::ExceptionOrResult,
            Capability::MacroAwareness,
            Capability::AsyncConcurrency,
            Capability::GeneratedCodeAwareness,
            // Source rewrite only for unambiguous fixes
            Capability::SourceRewrite,
        ])
    }
}