darklua_core/rules/
unused_while.rs

1use crate::nodes::{Block, Statement};
2use crate::process::{DefaultVisitor, Evaluator, NodeProcessor, NodeVisitor};
3use crate::rules::{
4    Context, FlawlessRule, RuleConfiguration, RuleConfigurationError, RuleProperties,
5};
6
7use super::verify_no_rule_properties;
8
9#[derive(Debug, Clone, Default)]
10struct WhileFilter {
11    evaluator: Evaluator,
12}
13
14impl NodeProcessor for WhileFilter {
15    fn process_block(&mut self, block: &mut Block) {
16        block.filter_statements(|statement| match statement {
17            Statement::While(while_statement) => {
18                let condition = while_statement.get_condition();
19
20                self.evaluator.has_side_effects(condition)
21                    || self
22                        .evaluator
23                        .evaluate(condition)
24                        .is_truthy()
25                        .unwrap_or(true)
26            }
27            _ => true,
28        });
29    }
30}
31
32pub const REMOVE_UNUSED_WHILE_RULE_NAME: &str = "remove_unused_while";
33
34/// A rule that removes while statements with a known false condition.
35#[derive(Debug, Default, PartialEq, Eq)]
36pub struct RemoveUnusedWhile {}
37
38impl FlawlessRule for RemoveUnusedWhile {
39    fn flawless_process(&self, block: &mut Block, _: &Context) {
40        let mut processor = WhileFilter::default();
41        DefaultVisitor::visit_block(block, &mut processor);
42    }
43}
44
45impl RuleConfiguration for RemoveUnusedWhile {
46    fn configure(&mut self, properties: RuleProperties) -> Result<(), RuleConfigurationError> {
47        verify_no_rule_properties(&properties)?;
48
49        Ok(())
50    }
51
52    fn get_name(&self) -> &'static str {
53        REMOVE_UNUSED_WHILE_RULE_NAME
54    }
55
56    fn serialize_to_properties(&self) -> RuleProperties {
57        RuleProperties::new()
58    }
59}
60
61#[cfg(test)]
62mod test {
63    use super::*;
64    use crate::rules::Rule;
65
66    use insta::assert_json_snapshot;
67
68    fn new_rule() -> RemoveUnusedWhile {
69        RemoveUnusedWhile::default()
70    }
71
72    #[test]
73    fn serialize_default_rule() {
74        let rule: Box<dyn Rule> = Box::new(new_rule());
75
76        assert_json_snapshot!("default_remove_unused_while", rule);
77    }
78
79    #[test]
80    fn configure_with_extra_field_error() {
81        let result = json5::from_str::<Box<dyn Rule>>(
82            r#"{
83            rule: 'remove_unused_while',
84            prop: "something",
85        }"#,
86        );
87        pretty_assertions::assert_eq!(result.unwrap_err().to_string(), "unexpected field 'prop'");
88    }
89}