crisp-errors 1.6.0

Fallibility analysis and CrispError enum synthesis (spec §9)
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

use crate::result::ErrorSet;

pub fn error_type_name_from_annotation(ty: &crisp_ast::ty::Type) -> Option<String> {
    use crisp_ast::ty::TypeKind;
    match &ty.kind {
        TypeKind::Named(id) => Some(id.name.clone()),
        TypeKind::Never => Some("never".into()),
        _ => None,
    }
}

pub fn declared_set_from_fn(def: &crisp_ast::item::FunctionDef) -> (Option<ErrorSet>, bool) {
    let Some(err) = &def.error_type else {
        return (None, false);
    };
    let mut set = ErrorSet::new();
    let mut asserts_never = false;
    for v in &err.variants {
        if let Some(name) = error_type_name_from_annotation(v) {
            if name == "never" {
                asserts_never = true;
            } else {
                set.insert(name);
            }
        }
    }
    (Some(set), asserts_never)
}

pub fn thrown_error_name(expr: &crisp_ast::expr::Expr) -> Option<String> {
    use crisp_ast::expr::ExprKind;
    match &expr.kind {
        ExprKind::Str(_) => Some("Thrown".into()),
        ExprKind::StructLit { name, .. } => Some(name.name.clone()),
        ExprKind::Call { func, .. } => {
            if let ExprKind::Ident(id) = &func.kind {
                return Some(id.name.clone());
            }
            None
        }
        ExprKind::Ident(id) => Some(id.name.clone()),
        _ => None,
    }
}

pub fn catch_handled_set(arms: &[crisp_ast::expr::CatchArm]) -> ErrorSet {
    use crisp_ast::pat::PatKind;
    let mut set = ErrorSet::new();
    for arm in arms {
        match &arm.pat.kind {
            PatKind::Wildcard => {
                return ErrorSet::from_iter(["*".into()]);
            }
            PatKind::Ident(id) if id.name == "_" => {
                return ErrorSet::from_iter(["*".into()]);
            }
            PatKind::Ident(id) => {
                set.insert(id.name.clone());
            }
            PatKind::Enum { variant, .. } => {
                set.insert(variant.name.clone());
            }
            PatKind::Struct { name, .. } => {
                set.insert(name.name.clone());
            }
            _ => {}
        }
    }
    set
}

pub fn absorbs_all(handled: &ErrorSet) -> bool {
    handled.contains("*")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn union_and_subtract() {
        let mut a = ErrorSet::new();
        a.insert("IoError");
        let mut b = ErrorSet::new();
        b.insert("ParseError");
        let u = ErrorSet::union(&a, &b);
        assert!(u.contains("IoError"));
        assert!(u.contains("ParseError"));
        let mut h = ErrorSet::new();
        h.insert("IoError");
        let r = ErrorSet::subtract(&u, &h);
        assert!(!r.contains("IoError"));
        assert!(r.contains("ParseError"));
    }
}