darklua_core/rules/
remove_unused_variable.rs1use 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 let mut remaining_unassigned_variables = Vec::new();
133
134 if let Some((last, value)) = assignments.last_mut() {
135 let remaining =
136 assign.iter_variables().zip(usages.iter()).skip(length);
137 if self.evaluator.can_return_multiple_values(value) {
138 last.extend(remaining);
139 } else {
140 remaining_unassigned_variables.extend(
141 remaining
142 .filter(|(_, used)| **used)
143 .map(|(identifier, _)| identifier.clone()),
144 );
145 }
146 }
147
148 let mut values: Vec<_> = remaining_unassigned_variables
149 .iter()
150 .map(|_| Expression::nil())
151 .collect();
152 let mut variables = remaining_unassigned_variables;
153
154 for (mut identifiers, value) in assignments {
155 let mut last_popped = None;
156
157 while identifiers.last().filter(|(_, used)| !*used).is_some() {
158 last_popped = identifiers.pop();
159 }
160
161 if !identifiers.is_empty() {
162 variables.extend(
163 identifiers
164 .into_iter()
165 .map(|(identifier, _)| identifier.clone()),
166 );
167 values.push(value.clone());
168 } else if self.evaluator.has_side_effects(value) {
169 if let Some((last_identifier, _)) = last_popped {
170 variables.push(last_identifier.clone());
171 values.push(value.clone());
172 }
173 }
174 }
175
176 if variables.is_empty() {
177 let extra_values: Vec<_> =
178 assign.iter_values().skip(length).cloned().collect();
179 if extra_values.is_empty() {
180 false
181 } else {
182 *statement = expressions_as_statement(extra_values);
183 true
184 }
185 } else {
186 values.extend(assign.iter_values().skip(length).cloned());
187 *statement = LocalAssignStatement::new(variables, values).into();
188 true
189 }
190 } else {
191 true
192 }
193 } else {
194 usages.iter().any(|used| *used)
195 };
196
197 if let Some((next_index, next_usages)) = usages_iter.next() {
198 find_next_index = next_index;
199 usages = next_usages;
200 } else {
201 should_find_next = false;
202 }
203
204 if !(self.mutated || keep_statement) {
205 self.mutated = true;
206 }
207
208 keep_statement
209 } else {
210 true
211 }
212 });
213 }
214 }
215}
216
217pub const REMOVE_UNUSED_VARIABLE_RULE_NAME: &str = "remove_unused_variable";
218
219#[derive(Debug, Default, PartialEq, Eq)]
221pub struct RemoveUnusedVariable {}
222
223impl FlawlessRule for RemoveUnusedVariable {
224 fn flawless_process(&self, block: &mut Block, _: &Context) {
225 loop {
226 let mut processor = RemoveUnusedVariableProcessor::default();
227 processor.process_scope(block, None);
228 DefaultVisitor::visit_block(block, &mut processor);
229 if !processor.has_mutated() {
230 break;
231 }
232 }
233 }
234}
235
236impl RuleConfiguration for RemoveUnusedVariable {
237 fn configure(&mut self, properties: RuleProperties) -> Result<(), RuleConfigurationError> {
238 verify_no_rule_properties(&properties)?;
239 Ok(())
240 }
241
242 fn get_name(&self) -> &'static str {
243 REMOVE_UNUSED_VARIABLE_RULE_NAME
244 }
245
246 fn serialize_to_properties(&self) -> RuleProperties {
247 RuleProperties::new()
248 }
249}
250
251#[cfg(test)]
252mod test {
253 use super::*;
254 use crate::rules::Rule;
255
256 use insta::assert_json_snapshot;
257
258 fn new_rule() -> RemoveUnusedVariable {
259 RemoveUnusedVariable::default()
260 }
261
262 #[test]
263 fn serialize_default_rule() {
264 let rule: Box<dyn Rule> = Box::new(new_rule());
265
266 assert_json_snapshot!("default_remove_unused_variable", rule);
267 }
268
269 #[test]
270 fn configure_with_extra_field_error() {
271 let result = json5::from_str::<Box<dyn Rule>>(
272 r#"{
273 rule: 'remove_unused_variable',
274 prop: "something",
275 }"#,
276 );
277 pretty_assertions::assert_eq!(result.unwrap_err().to_string(), "unexpected field 'prop'");
278 }
279}