darklua_core/rules/
remove_unused_variable.rs

1use crate::nodes::*;
2use crate::process::processors::FindUsage;
3use crate::process::{DefaultVisitor, Evaluator, NodeProcessor, NodeVisitor, ScopeVisitor};
4use crate::rules::{
5    Context, FlawlessRule, RuleConfiguration, RuleConfigurationError, RuleProperties,
6};
7use crate::utils::expressions_as_statement;
8
9use super::verify_no_rule_properties;
10
11#[derive(Default)]
12struct RemoveUnusedVariableProcessor {
13    evaluator: Evaluator,
14    mutated: bool,
15}
16
17impl RemoveUnusedVariableProcessor {
18    fn has_mutated(&self) -> bool {
19        self.mutated
20    }
21}
22
23impl NodeProcessor for RemoveUnusedVariableProcessor {
24    fn process_scope(&mut self, block: &mut Block, extra: Option<&mut Expression>) {
25        let length = block.statements_len();
26
27        let assignments = block
28            .reverse_iter_statements()
29            .enumerate()
30            .filter_map(|(i, statement)| match statement {
31                Statement::LocalAssign(assignment) => {
32                    let identifiers = assignment
33                        .get_variables()
34                        .iter()
35                        .map(TypedIdentifier::get_identifier)
36                        .map(Identifier::get_name)
37                        .map(ToOwned::to_owned)
38                        .collect::<Vec<_>>();
39
40                    Some((length - i - 1, identifiers))
41                }
42                Statement::LocalFunction(function) => {
43                    Some((length - i - 1, vec![function.get_name().to_owned()]))
44                }
45                _ => None,
46            })
47            .collect::<Vec<_>>();
48
49        let usages_in_extra = if let Some(expression) = extra {
50            let mut found_identifiers = Vec::new();
51            for (_, identifiers) in assignments.iter() {
52                for identifier in identifiers {
53                    let mut find_usage = FindUsage::new(identifier);
54                    ScopeVisitor::visit_expression(expression, &mut find_usage);
55                    if find_usage.has_found_usage() {
56                        found_identifiers.push(identifier.to_owned());
57                    }
58                }
59            }
60            found_identifiers
61        } else {
62            Vec::new()
63        };
64
65        let usages = assignments
66            .into_iter()
67            .map(|(index, identifiers)| {
68                let usages = identifiers
69                    .into_iter()
70                    .map(|identifier| {
71                        let mut find_usage = FindUsage::new(&identifier);
72
73                        block
74                            .iter_mut_statements()
75                            .skip(index + 1)
76                            .any(|next_statement| {
77                                ScopeVisitor::visit_statement(next_statement, &mut find_usage);
78                                find_usage.has_found_usage()
79                            })
80                            || block
81                                .mutate_last_statement()
82                                .into_iter()
83                                .any(|last_statement| {
84                                    ScopeVisitor::visit_last_statement(
85                                        last_statement,
86                                        &mut find_usage,
87                                    );
88                                    find_usage.has_found_usage()
89                                })
90                            || usages_in_extra.contains(&identifier)
91                    })
92                    .collect::<Vec<_>>();
93
94                (index, usages)
95            })
96            .collect::<Vec<_>>();
97
98        let mut usages_iter = usages.into_iter().rev();
99
100        if let Some((mut find_next_index, mut usages)) = usages_iter.next() {
101            let mut i = 0;
102            let mut should_find_next = true;
103
104            block.filter_mut_statements(|statement| {
105                let found = should_find_next && i == find_next_index;
106                i += 1;
107
108                if found {
109                    let keep_statement = if let Statement::LocalAssign(assign) = statement {
110                        if usages.iter().all(|used| !used) {
111                            let values = assign
112                                .iter_values()
113                                .filter(|value| self.evaluator.has_side_effects(value))
114                                .cloned()
115                                .collect::<Vec<_>>();
116
117                            if values.is_empty() {
118                                false
119                            } else {
120                                *statement = expressions_as_statement(values);
121                                true
122                            }
123                        } else if usages.iter().any(|used| !used) {
124                            let mut assignments: Vec<_> = assign
125                                .iter_variables()
126                                .zip(usages.iter())
127                                .map(|identifier| vec![identifier])
128                                .zip(assign.iter_values())
129                                .collect();
130
131                            let length = assignments.len();
132                            if let Some((last, value)) = assignments.last_mut() {
133                                if self.evaluator.can_return_multiple_values(value) {
134                                    last.extend(
135                                        assign.iter_variables().zip(usages.iter()).skip(length),
136                                    );
137                                }
138                            }
139
140                            let mut variables = Vec::new();
141                            let mut values = Vec::new();
142
143                            for (mut identifiers, value) in assignments {
144                                if !self.evaluator.has_side_effects(value) {
145                                    while identifiers.last().filter(|(_, used)| !*used).is_some() {
146                                        identifiers.pop();
147                                    }
148                                }
149
150                                if !identifiers.is_empty() {
151                                    variables.extend(
152                                        identifiers
153                                            .into_iter()
154                                            .map(|(identifier, _)| identifier.clone()),
155                                    );
156                                    values.push(value.clone());
157                                }
158                            }
159
160                            if variables.is_empty() {
161                                let extra_values: Vec<_> =
162                                    assign.iter_values().skip(length).cloned().collect();
163                                if extra_values.is_empty() {
164                                    false
165                                } else {
166                                    *statement = expressions_as_statement(extra_values);
167                                    true
168                                }
169                            } else {
170                                values.extend(assign.iter_values().skip(length).cloned());
171                                *statement = LocalAssignStatement::new(variables, values).into();
172                                true
173                            }
174                        } else {
175                            true
176                        }
177                    } else {
178                        usages.iter().any(|used| *used)
179                    };
180
181                    if let Some((next_index, next_usages)) = usages_iter.next() {
182                        find_next_index = next_index;
183                        usages = next_usages;
184                    } else {
185                        should_find_next = false;
186                    }
187
188                    if !(self.mutated || keep_statement) {
189                        self.mutated = true;
190                    }
191
192                    keep_statement
193                } else {
194                    true
195                }
196            });
197        }
198    }
199}
200
201pub const REMOVE_UNUSED_VARIABLE_RULE_NAME: &str = "remove_unused_variable";
202
203/// A rule that removes unused variables.
204#[derive(Debug, Default, PartialEq, Eq)]
205pub struct RemoveUnusedVariable {}
206
207impl FlawlessRule for RemoveUnusedVariable {
208    fn flawless_process(&self, block: &mut Block, _: &Context) {
209        loop {
210            let mut processor = RemoveUnusedVariableProcessor::default();
211            processor.process_scope(block, None);
212            DefaultVisitor::visit_block(block, &mut processor);
213            if !processor.has_mutated() {
214                break;
215            }
216        }
217    }
218}
219
220impl RuleConfiguration for RemoveUnusedVariable {
221    fn configure(&mut self, properties: RuleProperties) -> Result<(), RuleConfigurationError> {
222        verify_no_rule_properties(&properties)?;
223        Ok(())
224    }
225
226    fn get_name(&self) -> &'static str {
227        REMOVE_UNUSED_VARIABLE_RULE_NAME
228    }
229
230    fn serialize_to_properties(&self) -> RuleProperties {
231        RuleProperties::new()
232    }
233}
234
235#[cfg(test)]
236mod test {
237    use super::*;
238    use crate::rules::Rule;
239
240    use insta::assert_json_snapshot;
241
242    fn new_rule() -> RemoveUnusedVariable {
243        RemoveUnusedVariable::default()
244    }
245
246    #[test]
247    fn serialize_default_rule() {
248        let rule: Box<dyn Rule> = Box::new(new_rule());
249
250        assert_json_snapshot!("default_remove_unused_variable", rule);
251    }
252
253    #[test]
254    fn configure_with_extra_field_error() {
255        let result = json5::from_str::<Box<dyn Rule>>(
256            r#"{
257            rule: 'remove_unused_variable',
258            prop: "something",
259        }"#,
260        );
261        pretty_assertions::assert_eq!(result.unwrap_err().to_string(), "unexpected field 'prop'");
262    }
263}
darklua_core/rules/remove_unused_variable.rs

darklua_core/rules/
remove_unused_variable.rs
