rascal 0.2.5

A parser and compiler for Flash ActionScript 2 files into SWFs
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

use crate::internal::as2::ast::{BinaryOperator, UnaryOperator};
use crate::internal::as2::hir::visitor::{MutVisitor, walk_expr};
use crate::internal::as2::hir::{ConstantKind, Document, Expr, ExprKind};

struct Simplifier {
    anything_changed: bool,
}

impl MutVisitor for Simplifier {
    fn visit_expr(&mut self, expr: &mut Expr) {
        walk_expr(self, expr);
        match &mut expr.value {
            ExprKind::BinaryOperator(op, left, right) => {
                if let ExprKind::Constant(left) = &left.value
                    && let ExprKind::Constant(right) = &right.value
                {
                    #[expect(clippy::single_match)]
                    match (op, left, right) {
                        (
                            BinaryOperator::StringAdd,
                            ConstantKind::String(left),
                            ConstantKind::String(right),
                        ) => {
                            expr.value = ExprKind::Constant(ConstantKind::String(format!(
                                "{}{}",
                                left, right
                            )));
                            self.anything_changed = true;
                        }
                        _ => {}
                    }
                }
            }
            ExprKind::UnaryOperator(op, inner) => {
                if let ExprKind::Constant(value) = &inner.value {
                    #[expect(clippy::single_match)]
                    match (op, value) {
                        (UnaryOperator::LogicalNot, ConstantKind::Boolean(value)) => {
                            expr.value = ExprKind::Constant(ConstantKind::Boolean(!value));
                            self.anything_changed = true;
                        }
                        _ => {}
                    }
                }
            }
            _ => {}
        }
    }
}

pub fn simplify(document: &mut Document) -> bool {
    let mut simplifier = Simplifier {
        anything_changed: false,
    };

    match document {
        Document::Script { statements, .. } => {
            for statement in statements {
                simplifier.visit_statement(statement);
            }
        }
        Document::Interface(_interface) => {}
        Document::Class(_class) => {}
        Document::Invalid => {}
    }

    simplifier.anything_changed
}