knave 0.10.0

A small Lisp for humans and agents that infers types and ownership and compiles to readable Rust
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
74
75
76
77

use rustc_hash::{FxHashMap, FxHashSet};

use crate::core::BindingId;

#[derive(Default)]
pub struct Callers {
    callers: FxHashMap<BindingId, Vec<BindingId>>,
    recorded: FxHashSet<BindingId>,
}

impl Callers {
    pub fn record(&mut self, caller: BindingId, callees: &FxHashSet<BindingId>) {
        if !self.recorded.insert(caller) {
            return;
        }
        for callee in callees {
            self.callers.entry(*callee).or_default().push(caller);
        }
    }

    pub fn of_function(&self, callee: BindingId) -> &[BindingId] {
        self.callers.get(&callee).map_or(&[], Vec::as_slice)
    }
}

#[cfg(test)]
mod tests {
    use rustc_hash::FxHashSet;

    use super::Callers;
    use crate::core::{BindingArena, BindingId, BindingInfo, BindingKind, ModuleId};

    struct CallerFixture {
        bindings: BindingArena,
        callers: Callers,
    }

    impl CallerFixture {
        fn new() -> Self {
            Self {
                bindings: BindingArena::default(),
                callers: Callers::default(),
            }
        }

        fn function(&mut self, name: &str) -> BindingId {
            let kind = BindingKind::Global(ModuleId::new(0));
            self.bindings.add(BindingInfo::new(name.into(), kind, None))
        }

        fn record(&mut self, caller: BindingId, callees: &[BindingId]) {
            let callees: FxHashSet<BindingId> = callees.iter().copied().collect();
            self.callers.record(caller, &callees);
        }
    }

    #[test]
    fn a_callee_lists_each_function_that_calls_it() {
        let mut fixture = CallerFixture::new();
        let inner = fixture.function("inner");
        let middle = fixture.function("middle");
        let outer = fixture.function("outer");
        fixture.record(middle, &[inner]);
        fixture.record(outer, &[middle, inner]);
        assert_eq!(fixture.callers.of_function(inner), [middle, outer]);
    }

    #[test]
    fn a_caller_visited_again_is_listed_once() {
        let mut fixture = CallerFixture::new();
        let inner = fixture.function("inner");
        let middle = fixture.function("middle");
        fixture.record(middle, &[inner]);
        fixture.record(middle, &[inner]);
        assert_eq!(fixture.callers.of_function(inner), [middle]);
    }
}