darklua 0.19.0

Transform Lua scripts
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

use std::collections::HashSet;

use crate::{
    nodes::{Expression, FunctionAssignment, Identifier, TypeField},
    process::{NodeProcessor, Scope},
};

#[derive(Debug, Default)]
pub struct CollectGlobalsProcessor {
    scopes: Vec<HashSet<String>>,
    globals: HashSet<String>,
}

impl CollectGlobalsProcessor {
    pub(crate) fn add(&mut self, identifier: &str) {
        if self.scopes.is_empty() {
            self.scopes.push(HashSet::new());
        }

        let current = self.scopes.last_mut().unwrap();
        if !current.contains(identifier) {
            current.insert(identifier.to_owned());
        }
    }

    pub fn is_declared(&self, identifier: &str) -> bool {
        self.scopes
            .iter()
            .rev()
            .any(|scope| scope.contains(identifier))
    }

    pub fn iter_globals(&self) -> impl Iterator<Item = &str> {
        self.globals.iter().map(String::as_str)
    }

    pub fn into_globals(self) -> impl Iterator<Item = String> {
        self.globals.into_iter()
    }
}

impl Scope for CollectGlobalsProcessor {
    fn push(&mut self) {
        self.scopes.push(HashSet::new())
    }

    fn pop(&mut self) {
        self.scopes.pop();
    }

    fn insert(&mut self, identifier: &mut String) {
        self.add(identifier);
    }

    fn insert_self(&mut self) {
        self.add("self");
    }

    fn insert_local(&mut self, identifier: &mut String, _value: Option<&mut Expression>) {
        self.add(identifier);
    }

    fn insert_local_function(&mut self, function: &mut FunctionAssignment) {
        self.add(function.get_name());
    }
}

impl NodeProcessor for CollectGlobalsProcessor {
    fn process_variable_expression(&mut self, variable: &mut Identifier) {
        if !self.is_declared(variable.get_name()) {
            self.globals.insert(variable.get_name().clone());
        }
    }

    fn process_type_field(&mut self, type_field: &mut TypeField) {
        let namespace = type_field.get_namespace().get_name();
        if !self.is_declared(namespace) {
            self.globals.insert(namespace.clone());
        }
    }
}

#[cfg(test)]
mod test {
    use crate::{
        process::{NodeVisitor, ScopeVisitor},
        Parser,
    };

    use super::*;

    fn extract_globals(code: &str) -> Vec<String> {
        let mut processor = CollectGlobalsProcessor::default();

        let mut block = Parser::default()
            .parse(code)
            .expect("expected code should parse");

        ScopeVisitor::visit_block(&mut block, &mut processor);

        let mut globals = processor.into_globals().collect::<Vec<_>>();
        globals.sort();
        globals
    }

    #[test]
    fn catch_global_variable_in_module_scope() {
        insta::assert_debug_snapshot!(extract_globals(r#"
local g = game
return g
        "#), @r###"
        [
            "game",
        ]
        "###);
    }

    #[test]
    fn catch_global_variable_within_function_scope() {
        insta::assert_debug_snapshot!(extract_globals(r#"
local function example()
    return unpack(game:GetService("Players"):GetPlayers())
end

return { example = example }
        "#), @r###"
        [
            "game",
            "unpack",
        ]
        "###);
    }
}