dalbit 0.2.3

A Luau-to-Lua transpiler
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

use std::str::FromStr;

use anyhow::anyhow;
use darklua_core::{
    nodes::{Arguments, Block, Expression, Prefix, TableExpression},
    process::{DefaultVisitor, NodeProcessor, NodeVisitor},
    rules::{Context, FlawlessRule, RuleConfiguration, RuleConfigurationError, RuleProperties},
};

pub const OPTIMIZE_TABLE_INITIALIZERS_MODIFIER_NAME: &str = "optimize_table_initializers";

const DEFAULT_TABLE_LIBRARY: &str = "table";

#[non_exhaustive]
enum OptimizableTableMethod {
    Create,
    Freeze,
}

impl OptimizableTableMethod {
    fn try_optimize(&self, arguments: &Arguments) -> Option<Expression> {
        match self {
            OptimizableTableMethod::Create => {
                if let Arguments::Tuple(tuple) = arguments {
                    if tuple.len() < 2 {
                        return Some(Expression::Table(TableExpression::default()));
                    }
                }
            }
            OptimizableTableMethod::Freeze => match arguments {
                Arguments::Tuple(tuple) => {
                    let first_arg = tuple.iter_values().next();
                    return first_arg.cloned();
                }
                Arguments::Table(table) => {
                    return Some(Expression::Table(table.to_owned()));
                }
                _ => {
                    return None;
                }
            },
        };
        None
    }
}

impl FromStr for OptimizableTableMethod {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let optimizer = match s {
            "create" => OptimizableTableMethod::Create,
            "freeze" => OptimizableTableMethod::Freeze,
            _ => {
                return Err(anyhow!("Invalid OptimizableTableMethod `{}`", s));
            }
        };

        Ok(optimizer)
    }
}

struct Processor {}

impl NodeProcessor for Processor {
    fn process_expression(&mut self, exp: &mut Expression) {
        if let Expression::Call(func_call) = exp {
            let lib_and_call: Option<(&str, &str)> = match func_call.get_prefix() {
                Prefix::Field(field) => {
                    if let Prefix::Identifier(identifier) = field.get_prefix() {
                        Some((identifier.get_name(), field.get_field().get_name()))
                    } else {
                        None
                    }
                }
                Prefix::Index(index) => {
                    if let Expression::String(string) = index.get_index() {
                        if let Prefix::Identifier(identifier) = index.get_prefix() {
                            Some((identifier.get_name(), string.get_value()))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                }
                _ => None,
            };
            if let Some((lib_name, call_name)) = lib_and_call {
                if lib_name != DEFAULT_TABLE_LIBRARY {
                    return;
                }
                if let Ok(method) = OptimizableTableMethod::from_str(call_name) {
                    let new_exp = method.try_optimize(func_call.get_arguments());
                    if let Some(new_exp) = new_exp {
                        *exp = new_exp;
                    }
                }
            }
        }
    }
}

#[derive(Default, Debug)]
pub struct OptimizeTableInitializers {}

impl FlawlessRule for OptimizeTableInitializers {
    fn flawless_process(&self, block: &mut Block, _: &Context) {
        let mut processor = Processor {};
        DefaultVisitor::visit_block(block, &mut processor);
    }
}

impl RuleConfiguration for OptimizeTableInitializers {
    fn configure(&mut self, _: RuleProperties) -> Result<(), RuleConfigurationError> {
        Ok(())
    }

    fn get_name(&self) -> &'static str {
        OPTIMIZE_TABLE_INITIALIZERS_MODIFIER_NAME
    }

    fn serialize_to_properties(&self) -> darklua_core::rules::RuleProperties {
        RuleProperties::new()
    }
}