darklua 0.18.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
134
135

use crate::nodes::{
    Expression, FieldExpression, FunctionCall, Identifier, IndexExpression, ParentheseExpression,
    Token,
};

/// Represents a prefix expression.
///
/// Prefix expressions form the base for more complex expressions like method calls
/// and property access chains.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Prefix {
    /// A function call expression (e.g., `func()`)
    Call(Box<FunctionCall>),
    /// A field access expression (e.g., `object.field`)
    Field(Box<FieldExpression>),
    /// A simple name/variable (e.g., `variable_name`)
    Identifier(Identifier),
    /// An indexed access expression (e.g., `table[key]`)
    Index(Box<IndexExpression>),
    /// A parenthesized expression (e.g., `(expression)`)
    Parenthese(Box<ParentheseExpression>),
}

impl Prefix {
    /// Creates a new prefix from a name/identifier.
    pub fn from_name<S: Into<Identifier>>(name: S) -> Self {
        Self::Identifier(name.into())
    }

    /// Returns a mutable reference to the first token for this prefix chain,
    /// creating it if missing.
    pub fn mutate_first_token(&mut self) -> &mut Token {
        let mut current = self;
        loop {
            match current {
                Prefix::Call(call) => {
                    current = call.mutate_prefix();
                }
                Prefix::Field(field_expression) => {
                    current = field_expression.mutate_prefix();
                }
                Prefix::Index(index_expression) => {
                    current = index_expression.mutate_prefix();
                }
                Prefix::Identifier(identifier) => {
                    break identifier.mutate_or_insert_token();
                }
                Prefix::Parenthese(parenthese_expression) => {
                    break parenthese_expression.mutate_first_token();
                }
            }
        }
    }

    /// Returns a mutable reference to the last token for this prefix chain,
    /// creating it if missing.
    pub fn mutate_last_token(&mut self) -> &mut Token {
        match self {
            Prefix::Call(call) => call.mutate_last_token(),
            Prefix::Field(field_expression) => field_expression.mutate_last_token(),
            Prefix::Identifier(identifier) => identifier.mutate_or_insert_token(),
            Prefix::Index(index_expression) => index_expression.mutate_last_token(),
            Prefix::Parenthese(parenthese_expression) => parenthese_expression.mutate_last_token(),
        }
    }
}

impl From<Expression> for Prefix {
    fn from(expression: Expression) -> Self {
        match expression {
            Expression::Call(call) => Prefix::Call(call),
            Expression::Field(field) => Prefix::Field(field),
            Expression::Identifier(identifier) => Prefix::Identifier(identifier),
            Expression::Index(index) => Prefix::Index(index),
            Expression::Parenthese(parenthese) => Prefix::Parenthese(parenthese),
            Expression::Binary(_)
            | Expression::False(_)
            | Expression::Function(_)
            | Expression::If(_)
            | Expression::Nil(_)
            | Expression::Number(_)
            | Expression::String(_)
            | Expression::InterpolatedString(_)
            | Expression::Table(_)
            | Expression::True(_)
            | Expression::TypeCast(_)
            | Expression::Unary(_)
            | Expression::VariableArguments(_) => {
                Prefix::Parenthese(Box::new(ParentheseExpression::new(expression)))
            }
        }
    }
}

impl From<FunctionCall> for Prefix {
    fn from(call: FunctionCall) -> Self {
        Self::Call(Box::new(call))
    }
}

impl From<FieldExpression> for Prefix {
    fn from(field: FieldExpression) -> Self {
        Self::Field(field.into())
    }
}

impl From<Box<FieldExpression>> for Prefix {
    fn from(field: Box<FieldExpression>) -> Self {
        Self::Field(field)
    }
}

impl From<Identifier> for Prefix {
    fn from(identifier: Identifier) -> Self {
        Self::Identifier(identifier)
    }
}

impl From<IndexExpression> for Prefix {
    fn from(index: IndexExpression) -> Self {
        Self::Index(index.into())
    }
}

impl From<Box<IndexExpression>> for Prefix {
    fn from(index: Box<IndexExpression>) -> Self {
        Self::Index(index)
    }
}

impl From<ParentheseExpression> for Prefix {
    fn from(expression: ParentheseExpression) -> Self {
        Self::Parenthese(Box::new(expression))
    }
}