cea-core 0.1.0

cea-core — RecursiveIntell Forge primitive
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

use crate::types::ScopeTag;

pub(crate) fn infer_scope(context: &[String]) -> ScopeTag {
    let sanitized = strip_comments_and_strings(context);
    for line in sanitized.lines().rev() {
        let tokens = tokenize(line);
        if tokens.is_empty() {
            continue;
        }

        if tokens.contains(&"macro_rules") {
            return ScopeTag::Macro;
        }
        if tokens.contains(&"fn") {
            return ScopeTag::Function;
        }
        if tokens.contains(&"impl") {
            return ScopeTag::Implementation;
        }
        if tokens.contains(&"struct") {
            return ScopeTag::Struct;
        }
        if tokens.contains(&"enum") {
            return ScopeTag::Enum;
        }
        if tokens.contains(&"trait") {
            return ScopeTag::Trait;
        }
        if tokens.contains(&"mod") {
            return ScopeTag::Module;
        }
    }

    ScopeTag::Unknown
}

fn tokenize(line: &str) -> Vec<&str> {
    line.split(|ch: char| !(ch.is_ascii_alphanumeric() || ch == '_'))
        .filter(|token| !token.is_empty())
        .collect()
}

fn strip_comments_and_strings(context: &[String]) -> String {
    let mut output = String::new();
    let mut in_block_comment = 0_u32;
    let mut in_string = false;
    let mut in_char = false;
    let mut escaped = false;

    for line in context {
        let mut chars = line.chars().peekable();
        while let Some(ch) = chars.next() {
            if in_block_comment > 0 {
                if ch == '*' && chars.peek() == Some(&'/') {
                    chars.next();
                    in_block_comment -= 1;
                } else if ch == '/' && chars.peek() == Some(&'*') {
                    chars.next();
                    in_block_comment += 1;
                }
                continue;
            }

            if in_string {
                if escaped {
                    escaped = false;
                    continue;
                }
                match ch {
                    '\\' => escaped = true,
                    '"' => in_string = false,
                    _ => {}
                }
                continue;
            }

            if in_char {
                if escaped {
                    escaped = false;
                    continue;
                }
                match ch {
                    '\\' => escaped = true,
                    '\'' => in_char = false,
                    _ => {}
                }
                continue;
            }

            if ch == '/' && chars.peek() == Some(&'/') {
                break;
            }
            if ch == '/' && chars.peek() == Some(&'*') {
                chars.next();
                in_block_comment += 1;
                continue;
            }
            if ch == '"' {
                in_string = true;
                continue;
            }
            if ch == '\'' {
                in_char = true;
                continue;
            }

            output.push(ch);
        }
        output.push('\n');
    }

    output
}