factorio-ir 0.4.0

Intermediate representation for factorio-rs Rust-to-Lua Factorio mod transpilation
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

use crate::{expression::Expression, literal::Literal, operator::Operator, statement::Statement};

/// `local x = nil; x = e` -> `local x = e` (no intervening use of `x`).
pub(super) fn collapse_nil_inits(stmts: &[Statement]) -> Vec<Statement> {
    let mut out = Vec::with_capacity(stmts.len());
    let mut i = 0;
    while i < stmts.len() {
        if let Statement::VariableDecl {
            name,
            ty,
            source_type,
            value: Expression::Literal(Literal::Nil),
        } = &stmts[i]
            && let Some(Statement::Assignment {
                target: Expression::Identifier(dest),
                value,
            }) = stmts.get(i + 1)
            && dest == name
        {
            out.push(Statement::VariableDecl {
                name: name.clone(),
                ty: ty.clone(),
                source_type: source_type.clone(),
                value: value.clone(),
            });
            i += 2;
            continue;
        }
        out.push(stmts[i].clone());
        i += 1;
    }
    out
}

/// `if v ~= nil then local x = v; return x end` -> `return v` (identity binds).
pub(super) fn simplify_identity_binds(block: &mut Vec<Statement>) {
    if let [
        Statement::VariableDecl { name, value, .. },
        Statement::Return(Some(Expression::Identifier(ret))),
    ] = block.as_slice()
        && name == ret
    {
        *block = vec![Statement::Return(Some(value.clone()))];
        return;
    }
    if let [
        Statement::VariableDecl { name, value, .. },
        Statement::Assignment {
            target,
            value: Expression::Identifier(src),
        },
    ] = block.as_slice()
        && name == src
    {
        *block = vec![Statement::Assignment {
            target: target.clone(),
            value: value.clone(),
        }];
    }
}

/// `if v ~= nil then ... else if v == nil then BODY end end` -> else BODY.
pub(super) fn drop_redundant_nil_else(condition: &Expression, else_block: &mut Vec<Statement>) {
    let Some(name) = super::unwrap_or::ne_nil_ident(condition) else {
        return;
    };
    if let [
        Statement::Conditional {
            condition: inner_cond,
            then_block,
            else_block: inner_else,
        },
    ] = else_block.as_slice()
        && is_eq_nil(inner_cond, &name)
        && inner_else.is_empty()
    {
        *else_block = then_block.clone();
    }
}

fn is_eq_nil(condition: &Expression, name: &str) -> bool {
    matches!(
        condition,
        Expression::BinaryOp {
            lhs,
            op: Operator::Eq,
            rhs,
        } if matches!(lhs.as_ref(), Expression::Identifier(id) if id == name)
            && matches!(rhs.as_ref(), Expression::Literal(Literal::Nil))
    )
}