unluac 1.0.0

Multi-dialect Lua decompiler written in Rust.
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! 这个文件承载 `branch_value_exprs` 模块的局部不变量测试。
//!
//! 这里重点锁两件事：
//! 1. 机械 branch-local 值壳会在 HIR 内部直接收成值表达式；
//! 2. 自引用或值表达式本身不适合参与 HIR `Decision` 综合的形状仍然保留原样。

use super::*;
use crate::hir::common::{
    HirAssign, HirBinaryExpr, HirBinaryOpKind, HirCallExpr, HirGlobalRef, HirProtoRef, HirReturn,
};
use crate::parser::{ProtoLineRange, ProtoSignature};

#[test]
fn collapses_branch_assigned_local_into_initializer_expr() {
    let mut proto = dummy_proto(HirBlock {
        stmts: vec![
            HirStmt::LocalDecl(Box::new(HirLocalDecl {
                bindings: vec![LocalId(0)],
                values: vec![],
            })),
            HirStmt::If(Box::new(HirIf {
                cond: HirExpr::ParamRef(crate::hir::common::ParamId(0)),
                then_block: HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::String("neg".to_owned())],
                    }))],
                },
                else_block: Some(HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::String("pos".to_owned())],
                    }))],
                }),
            })),
            HirStmt::Return(Box::new(HirReturn {
                values: vec![HirExpr::LocalRef(LocalId(0))],
            })),
        ],
    });

    assert!(collapse_branch_value_locals_in_proto(&mut proto));
    assert!(matches!(
        proto.body.stmts.as_slice(),
        [HirStmt::LocalDecl(local_decl), HirStmt::Return(_)]
            if matches!(
                (local_decl.bindings.as_slice(), local_decl.values.as_slice()),
                ([LocalId(0)], [HirExpr::LogicalOr(or_expr)])
                    if matches!(
                        (&or_expr.lhs, &or_expr.rhs),
                        (
                            HirExpr::LogicalAnd(and_expr),
                            HirExpr::String(falsy),
                        ) if matches!(
                            (&and_expr.lhs, &and_expr.rhs),
                            (
                                HirExpr::ParamRef(crate::hir::common::ParamId(0)),
                                HirExpr::String(truthy),
                            ) if truthy == "neg" && falsy == "pos"
                        )
                    )
            )
    ));
}

#[test]
fn keeps_branch_local_when_branch_reads_declared_binding() {
    let mut proto = dummy_proto(HirBlock {
        stmts: vec![
            HirStmt::LocalDecl(Box::new(HirLocalDecl {
                bindings: vec![LocalId(0)],
                values: vec![],
            })),
            HirStmt::If(Box::new(HirIf {
                cond: HirExpr::Binary(Box::new(HirBinaryExpr {
                    op: HirBinaryOpKind::Eq,
                    lhs: HirExpr::LocalRef(LocalId(0)),
                    rhs: HirExpr::Nil,
                })),
                then_block: HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::String("neg".to_owned())],
                    }))],
                },
                else_block: Some(HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::String("pos".to_owned())],
                    }))],
                }),
            })),
        ],
    });

    assert!(!collapse_branch_value_locals_in_proto(&mut proto));
    assert_eq!(proto.body.stmts.len(), 2);
}

#[test]
fn keeps_branch_local_when_branch_value_is_not_synth_safe() {
    let mut proto = dummy_proto(HirBlock {
        stmts: vec![
            HirStmt::LocalDecl(Box::new(HirLocalDecl {
                bindings: vec![LocalId(0)],
                values: vec![],
            })),
            HirStmt::If(Box::new(HirIf {
                cond: HirExpr::ParamRef(crate::hir::common::ParamId(0)),
                then_block: HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::Call(Box::new(HirCallExpr {
                            callee: HirExpr::GlobalRef(HirGlobalRef {
                                name: "truthy_branch".to_owned(),
                            }),
                            args: vec![],
                            multiret: false,
                            method: false,
                            method_name: None,
                        }))],
                    }))],
                },
                else_block: Some(HirBlock {
                    stmts: vec![HirStmt::Assign(Box::new(HirAssign {
                        targets: vec![HirLValue::Local(LocalId(0))],
                        values: vec![HirExpr::Call(Box::new(HirCallExpr {
                            callee: HirExpr::GlobalRef(HirGlobalRef {
                                name: "falsy_branch".to_owned(),
                            }),
                            args: vec![],
                            multiret: false,
                            method: false,
                            method_name: None,
                        }))],
                    }))],
                }),
            })),
        ],
    });

    assert!(!collapse_branch_value_locals_in_proto(&mut proto));
    assert_eq!(proto.body.stmts.len(), 2);
}

fn dummy_proto(body: HirBlock) -> crate::hir::common::HirProto {
    crate::hir::common::HirProto {
        id: HirProtoRef(0),
        source: None,
        line_range: ProtoLineRange {
            defined_start: 0,
            defined_end: 0,
        },
        signature: ProtoSignature {
            num_params: 1,
            is_vararg: false,
            has_vararg_param_reg: false,
            named_vararg_table: false,
        },
        params: vec![crate::hir::common::ParamId(0)],
        locals: vec![LocalId(0)],
        local_debug_hints: Vec::new(),
        upvalues: Vec::new(),
        temps: Vec::new(),
        temp_debug_locals: Vec::new(),
        body,
        children: Vec::new(),
    }
}