swamp-refs 0.2.21

symbol references
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
73

pub mod prelude;

use seq_map::SeqMap;
use source_map_node::Node;
use swamp_symbol::SymbolId;

#[derive(Debug, Clone)]
pub struct ReferenceTracker {
    map: SeqMap<SymbolId, Vec<Node>>,
}

impl Default for ReferenceTracker {
    fn default() -> Self {
        Self::new()
    }
}

impl ReferenceTracker {
    #[must_use] pub fn new() -> Self {
        Self { map: SeqMap::new() }
    }

    pub fn add(&mut self, symbol: SymbolId, usage_site: Node) {
        if let Some(vec) = self.map.get_mut(&symbol) {
            vec.push(usage_site);
        } else {
            self.map.insert(symbol, vec![usage_site]).unwrap();
        }
    }

    #[must_use] pub fn get(&self, symbol: SymbolId) -> Option<&[Node]> {
        self.map.get(&symbol).map(std::vec::Vec::as_slice)
    }

    #[must_use] pub fn is_used(&self, symbol: &SymbolId) -> bool {
        self.map.get(symbol).is_some_and(|v| !v.is_empty())
    }

    pub fn iter(&self) -> impl Iterator<Item=(&SymbolId, &[Node])> {
        self.map.iter().map(|(id, nodes)| (id, nodes.as_slice()))
    }
}

#[derive(Clone, Debug)]
pub struct SymbolReference {
    pub usage_node: Node,
    pub pointing_to_symbol_id: SymbolId,
}

#[derive(Clone, Debug)]
pub struct ModuleSymbolReferences {
    pub refs: Vec<SymbolReference>,
}

impl Default for ModuleSymbolReferences {
    fn default() -> Self {
        Self::new()
    }
}

impl ModuleSymbolReferences {
    #[must_use] pub const fn new() -> Self {
        Self {
            refs: Vec::new(),
        }
    }
    pub fn add(&mut self, symbol_id: SymbolId, usage_site: Node) {
        self.refs.push(SymbolReference {
            pointing_to_symbol_id: symbol_id,
            usage_node: usage_site,
        });
    }
}