knave 0.14.22

A Lisp programming language 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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::rc::Rc;

use super::name_records::NameRecords;
use super::set_aside_drop::SetAsideDrop;
use super::set_aside_source::SetAsideSource;
use crate::diagnostic::Diagnostic;
use crate::expand::{BoundName, InputTerms, SetAsideInput, SetAsideProblems};

pub struct DroppedDefinitions {
    source: SetAsideSource,
    dropped: Vec<BoundName>,
    replacing: Rc<str>,
}

impl DroppedDefinitions {
    pub fn left_behind(
        source: SetAsideSource,
        earlier: &InputTerms,
        entered: &InputTerms,
    ) -> Option<Self> {
        let dropped: Vec<BoundName> = earlier
            .bound()
            .iter()
            .filter(|name| !entered.binds(name))
            .cloned()
            .collect();
        let replacing = entered.bound().iter().find(|bound| earlier.binds(bound))?;
        (!dropped.is_empty()).then(|| Self {
            source,
            dropped,
            replacing: Rc::clone(&replacing.name),
        })
    }
}

impl SetAsideDrop for DroppedDefinitions {
    fn warning(&self, setter: &str) -> Diagnostic {
        let names: Vec<&str> = self.dropped.iter().map(|name| &*name.name).collect();
        let input = SetAsideInput {
            names: &names,
            source: &self.source.name,
            setter,
        };
        SetAsideProblems::dropped_definitions(&input, &self.replacing, self.dropped[0].span)
    }

    fn record(&self, records: &mut NameRecords, setter: &str) {
        for name in &self.dropped {
            let reason = SetAsideProblems::set_aside_reason(&self.replacing, &name.name);
            records.set_aside(name, setter, &reason);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::name_records::Tense;
    use crate::core::Namespace;
    use crate::diagnostic::MissingName;
    use crate::source::{SourceId, Span};

    struct DefinitionsFixture;

    impl DefinitionsFixture {
        const SOURCE: &str = "<input 2>";
        const SETTER: &str = "<input 3>";

        fn name(name: &str) -> BoundName {
            BoundName {
                name: name.into(),
                namespace: Namespace::Value,
                span: Span::new(SourceId::new(0), 0..1),
            }
        }

        fn terms(names: &[&str]) -> InputTerms {
            InputTerms::binding(names.iter().map(|name| Self::name(name)).collect())
        }

        fn source() -> SetAsideSource {
            SetAsideSource {
                name: Self::SOURCE.to_string(),
                span: Span::new(SourceId::new(0), 0..1),
            }
        }

        fn dropped() -> DroppedDefinitions {
            DroppedDefinitions::left_behind(
                Self::source(),
                &Self::terms(&["a", "b"]),
                &Self::terms(&["b"]),
            )
            .expect("`b` replaces the input that also defined `a`")
        }
    }

    #[test]
    fn a_replacement_that_keeps_every_name_leaves_nothing_behind() {
        let earlier = DefinitionsFixture::terms(&["a"]);
        let left =
            DroppedDefinitions::left_behind(DefinitionsFixture::source(), &earlier, &earlier);
        assert!(left.is_none());
    }

    #[test]
    fn an_input_that_replaces_nothing_leaves_nothing_behind() {
        let left = DroppedDefinitions::left_behind(
            DefinitionsFixture::source(),
            &DefinitionsFixture::terms(&["a"]),
            &DefinitionsFixture::terms(&["c"]),
        );
        assert!(left.is_none());
    }

    #[test]
    fn the_warning_names_the_definitions_left_behind() {
        let warning = DefinitionsFixture::dropped().warning(DefinitionsFixture::SETTER);
        assert_eq!(warning.title(), "set aside `a` after `<input 3>`");
        assert_eq!(warning.notes(), ["`b` replaced the input that defined `a`"]);
    }

    #[test]
    fn each_definition_left_behind_is_recorded_as_set_aside() {
        let mut records = NameRecords::default();
        DefinitionsFixture::dropped().record(&mut records, DefinitionsFixture::SETTER);
        let missing = MissingName {
            name: "a".into(),
            namespace: Namespace::Value,
        };
        assert_eq!(
            records.note(&missing, Tense::Done).as_deref(),
            Some("`<input 3>` set aside `a`: `b` replaced the input that defined `a`")
        );
    }
}