unluac 1.1.1

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

//! 这个文件集中放 AST 输出层共享的“源码形态偏好”启发式。
//!
//! AST 本身只保存稳定语义，不会专门为 `elseif`、`>` / `>=` 之类的打印糖再扩一层
//! 语法节点。这里提供跨 debug / generate 共享的轻量规则，让不同输出入口在不改变
//! AST 语义的前提下，尽量收敛到更接近源码的文本形状。
//! 例如：默认步长的 numeric-for 可以在输出层省略第三个参数。

use super::common::{
    AstBinaryExpr, AstBinaryOpKind, AstExpr, AstTableField, AstTableKey, AstUnaryExpr,
    AstUnaryOpKind,
};

pub(crate) struct PreferredRelationalRender<'a> {
    pub(crate) lhs: &'a AstExpr,
    pub(crate) op_text: &'static str,
    pub(crate) rhs: &'a AstExpr,
}

pub(crate) fn preferred_relational_render(
    binary: &AstBinaryExpr,
) -> Option<PreferredRelationalRender<'_>> {
    let flipped = should_flip_relational_operands(&binary.lhs, &binary.rhs);
    match (binary.op, flipped) {
        (AstBinaryOpKind::Lt, false) => Some(PreferredRelationalRender {
            lhs: &binary.lhs,
            op_text: "<",
            rhs: &binary.rhs,
        }),
        (AstBinaryOpKind::Lt, true) => Some(PreferredRelationalRender {
            lhs: &binary.rhs,
            op_text: ">",
            rhs: &binary.lhs,
        }),
        (AstBinaryOpKind::Le, false) => Some(PreferredRelationalRender {
            lhs: &binary.lhs,
            op_text: "<=",
            rhs: &binary.rhs,
        }),
        (AstBinaryOpKind::Le, true) => Some(PreferredRelationalRender {
            lhs: &binary.rhs,
            op_text: ">=",
            rhs: &binary.lhs,
        }),
        _ => None,
    }
}

pub(crate) fn preferred_negated_relational_render(
    unary: &AstUnaryExpr,
) -> Option<PreferredRelationalRender<'_>> {
    if unary.op != AstUnaryOpKind::Not {
        return None;
    }
    let AstExpr::Binary(binary) = &unary.expr else {
        return None;
    };
    if binary.op != AstBinaryOpKind::Eq {
        return None;
    }

    Some(PreferredRelationalRender {
        lhs: &binary.lhs,
        op_text: "~=",
        rhs: &binary.rhs,
    })
}

pub(crate) fn is_default_numeric_for_step(step: &AstExpr) -> bool {
    match step {
        AstExpr::Integer(1) => true,
        AstExpr::Number(value) => *value == 1.0,
        _ => false,
    }
}

fn should_flip_relational_operands(lhs: &AstExpr, rhs: &AstExpr) -> bool {
    expr_display_complexity(lhs) < expr_display_complexity(rhs)
}

fn expr_display_complexity(expr: &AstExpr) -> usize {
    match expr {
        AstExpr::Nil
        | AstExpr::Boolean(_)
        | AstExpr::Integer(_)
        | AstExpr::Number(_)
        | AstExpr::String(_)
        | AstExpr::Int64(_)
        | AstExpr::UInt64(_)
        | AstExpr::Complex { .. } => 1,
        // 把变量刻意排在常量之上，这样 `0 < value` 会更倾向翻成 `value > 0`。
        AstExpr::Var(_) | AstExpr::VarArg => 2,
        AstExpr::Unary(unary) => 1 + expr_display_complexity(&unary.expr),
        AstExpr::FieldAccess(access) => 2 + expr_display_complexity(&access.base),
        AstExpr::IndexAccess(access) => {
            2 + expr_display_complexity(&access.base) + expr_display_complexity(&access.index)
        }
        AstExpr::Binary(binary) => {
            1 + expr_display_complexity(&binary.lhs) + expr_display_complexity(&binary.rhs)
        }
        AstExpr::LogicalAnd(logical) | AstExpr::LogicalOr(logical) => {
            1 + expr_display_complexity(&logical.lhs) + expr_display_complexity(&logical.rhs)
        }
        AstExpr::Call(call) => {
            3 + expr_display_complexity(&call.callee)
                + call.args.iter().map(expr_display_complexity).sum::<usize>()
        }
        AstExpr::SingleValue(expr) => 1 + expr_display_complexity(expr),
        AstExpr::MethodCall(call) => {
            3 + expr_display_complexity(&call.receiver)
                + call.args.iter().map(expr_display_complexity).sum::<usize>()
        }
        AstExpr::TableConstructor(table) => {
            2 + table
                .fields
                .iter()
                .map(|field| match field {
                    AstTableField::Array(value) => expr_display_complexity(value),
                    AstTableField::Record(record) => {
                        let key_cost = match &record.key {
                            AstTableKey::Name(_) => 1,
                            AstTableKey::Expr(key) => expr_display_complexity(key),
                        };
                        key_cost + expr_display_complexity(&record.value)
                    }
                })
                .sum::<usize>()
        }
        AstExpr::FunctionExpr(function) => 2 + function.body.stmts.len(),
        AstExpr::Error(_) => 1,
    }
}

#[cfg(test)]
mod tests;