elint 0.1.1

Erlang code linter
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

//! `strict_generator` lint: require strict comprehension generators.

use super::{Rule, token_span_in_node};
use crate::{BranchContext, Context, Finding};

/// Lint rule that flags relaxed comprehension generators.
pub const RULE: Rule = Rule::new(
    "strict_generator",
    include_str!("../../rules/strict_generator/rule.md"),
    check,
);

fn check(_ctx: &Context, branch: &BranchContext) -> Vec<Finding> {
    let mut errors = Vec::new();
    for root in branch.tree.roots() {
        walk(branch, root, &mut errors);
    }
    errors
}

fn walk(branch: &BranchContext, node: erl_parse::NodeView<'_>, errors: &mut Vec<Finding>) {
    if node.kind() == erl_parse::SyntaxKind::ZipQualifier {
        return;
    }
    check_node(branch, node, errors);
    for child in node.children() {
        walk(branch, child, errors);
    }
}

fn check_node(branch: &BranchContext, node: erl_parse::NodeView<'_>, errors: &mut Vec<Finding>) {
    let expected = match node.kind() {
        erl_parse::SyntaxKind::Generator | erl_parse::SyntaxKind::MapGenerator => {
            erl_tokenize::Symbol::LeftArrow
        }
        erl_parse::SyntaxKind::BitstringGenerator => erl_tokenize::Symbol::DoubleLeftArrow,
        _ => return,
    };
    let Some(span) = token_span_in_node(branch, node, |token| {
        token.kind() == erl_tokenize::TokenKind::Symbol(expected)
    }) else {
        return;
    };
    errors.push(Finding {
        span,
        node: node.node_id(),
    });
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::rules::test_support::findings;

    #[test]
    fn flags_list_generator() {
        let src = "-module(t).\nfoo() -> [X || X <- [1, 2, 3]].\n";
        assert_eq!(findings(check, src), ["<-"]);
    }

    #[test]
    fn flags_bitstring_generator() {
        let src = "-module(t).\nfoo() -> [X || <<X:8>> <= <<1, 2, 3>>].\n";
        assert_eq!(findings(check, src), ["<="]);
    }

    #[test]
    fn flags_map_generator() {
        let src = "-module(t).\nfoo(M) -> #{K => V || K := V <- M}.\n";
        assert_eq!(findings(check, src), ["<-"]);
    }

    #[test]
    fn ignores_strict_list_generator() {
        let src = "-module(t).\nfoo() -> [X || X <:- [1, 2, 3]].\n";
        assert!(findings(check, src).is_empty());
    }

    #[test]
    fn ignores_strict_bitstring_generator() {
        let src = "-module(t).\nfoo() -> [X || <<X:8>> <:= <<1, 2, 3>>].\n";
        assert!(findings(check, src).is_empty());
    }

    #[test]
    fn ignores_strict_map_generator() {
        let src = "-module(t).\nfoo(M) -> #{K => V || K := V <:- M}.\n";
        assert!(findings(check, src).is_empty());
    }

    #[test]
    fn ignores_zip_generator() {
        let src = "-module(t).\nfoo() -> [{X, Y} || X <- [1, 2] && Y <- [3, 4]].\n";
        assert!(findings(check, src).is_empty());
    }

    #[test]
    fn flags_each_generator_in_a_comprehension_once() {
        let src = "-module(t).\nfoo() -> [[X || X <- L] || L <- [[1], [2]]].\n";
        assert_eq!(findings(check, src), ["<-", "<-"]);
    }

    #[test]
    fn ng_fixture_has_three_findings() {
        let src = include_str!("../../rules/strict_generator/ng.erl");
        assert_eq!(findings(check, src).len(), 3);
    }

    #[test]
    fn ok_fixture_has_no_findings() {
        let src = include_str!("../../rules/strict_generator/ok.erl");
        assert!(findings(check, src).is_empty());
    }
}