lua_semantics 0.9.0

semantic analysis and enhanced AST converter for lua_parser crate
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

use crate::FloatType;
use crate::IntOrFloat;
use crate::IntType;

/// lua value & expression
#[non_exhaustive]
#[derive(Clone, Debug)]
pub enum Expression {
    /// _ENV
    Env,

    Variadic,

    Nil,
    Boolean(bool),
    Numeric(IntOrFloat),
    String(Vec<u8>),

    /// load from stack
    LocalVariable(ExprLocalVariable),

    /// `table[index]`.
    TableIndex(ExprTableIndex),

    /// binary operation. `lhs OP rhs`
    Binary(ExprBinary),
    /// unary operation. `OP x`
    Unary(ExprUnary),

    /// table constructor
    TableConstructor(ExprTableConstructor),

    /// function call.
    /// `prefix(args)` or `prefix:method(args)`
    FunctionCall(ExprFunctionCall),

    /// function object constructor
    FunctionObject(ExprFunctionObject),
}

impl From<()> for Expression {
    fn from(_: ()) -> Self {
        Expression::Nil
    }
}
impl From<bool> for Expression {
    fn from(value: bool) -> Self {
        Expression::Boolean(value)
    }
}
impl From<IntOrFloat> for Expression {
    fn from(value: IntOrFloat) -> Self {
        Expression::Numeric(value)
    }
}
impl From<IntType> for Expression {
    fn from(value: IntType) -> Self {
        Expression::Numeric(value.into())
    }
}
impl From<FloatType> for Expression {
    fn from(value: FloatType) -> Self {
        Expression::Numeric(value.into())
    }
}
impl From<Vec<u8>> for Expression {
    fn from(value: Vec<u8>) -> Self {
        Expression::String(value)
    }
}
impl From<String> for Expression {
    fn from(value: String) -> Self {
        Expression::String(value.into_bytes())
    }
}

impl Expression {}

// mod literal;
// pub use literal::ExprVariadic;

mod table;
pub use table::ExprTableConstructor;

mod localvar;
pub use localvar::ExprLocalVariable;

mod index;
pub use index::ExprTableIndex;

mod binary;
pub use binary::ExprBinary;
pub use binary::ExprBinaryData;

mod unary;
pub use unary::ExprUnary;
pub use unary::ExprUnaryData;

mod functioncall;
pub use functioncall::ExprFunctionCall;

mod function;
pub use function::ExprFunctionObject;
pub use function::FunctionDefinition;