elint 0.0.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

use erl_tokenize::PositionRange;

use crate::item::Span;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Token {
    pub kind: TokenKind,
    pub span: Span,
}

impl Token {
    pub fn text(self, full_text: &str) -> &str {
        self.span.text(full_text)
    }

    pub fn is_binary_op(self, text: &str) -> bool {
        if !matches!(self.kind, TokenKind::Keyword | TokenKind::Symbol) {
            return false;
        }

        // TODO: add other kw / symbol(erlang)
        matches!(
            self.text(text),
            "*" | "+"
                | "++"
                | "-"
                | "--"
                | "/"
                | "=="
                | "=:="
                | "=/="
                | "<"
                | ">"
                | "=<"
                | ">="
                | "|"
                | "!"
                | "bsl"
                | "bsr"
                | "band"
                | "bor"
                | "bxor"
                | "orelse"
                | "andalso"
                | "or"
                | "and"
                | "div"
                | "rem"
                | "mod"
        )
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TokenKind {
    Atom,
    Variable,
    Integer,
    Float,
    Char,
    String,
    SigilString,
    Keyword,
    Symbol,
    Comment,
}

pub fn tokenize(text: &str) -> Result<Vec<Token>, erl_tokenize::Error> {
    let mut tokens = Vec::new();
    let tokenizer = erl_tokenize::Tokenizer::new(text);

    let mut is_macro = false;
    for token_result in tokenizer {
        let erl_token = token_result?;
        let span = Span {
            start: erl_token.start_position().offset(),
            end: erl_token.end_position().offset(),
        };

        // TODO: Handle macro properly
        let kind = match erl_token {
            erl_tokenize::Token::Atom(_) => TokenKind::Atom,
            erl_tokenize::Token::Variable(_) if is_macro => TokenKind::Atom,
            erl_tokenize::Token::Variable(_) => TokenKind::Variable,
            erl_tokenize::Token::Integer(_) => TokenKind::Integer,
            erl_tokenize::Token::Float(_) => TokenKind::Float,
            erl_tokenize::Token::Char(_) => TokenKind::Char,
            erl_tokenize::Token::String(_) => TokenKind::String,
            erl_tokenize::Token::SigilString(_) => TokenKind::SigilString,
            erl_tokenize::Token::Keyword(_) => TokenKind::Keyword,
            erl_tokenize::Token::Symbol(t)
                if t.value() == erl_tokenize::values::Symbol::Question =>
            {
                is_macro = true;
                continue;
            }
            erl_tokenize::Token::Symbol(_) => TokenKind::Symbol,
            erl_tokenize::Token::Comment(_) => TokenKind::Comment,
            erl_tokenize::Token::Whitespace(_) => continue,
        };

        is_macro = false;
        tokens.push(Token { kind, span });
    }

    Ok(tokens)
}