reluxscript 0.1.4

Write AST transformations once. Compile to Babel, SWC, and beyond.
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

/**
 * Test: 'is' Pattern Matching Syntax
 *
 * C# developers write:
 *   if (node is Identifier id) { ... }
 *
 * Instead of Rust-style:
 *   if let Identifier(id) = node { ... }
 */
plugin IsPattern {

    struct State {
        result: Str,
    }

    fn init() -> State {
        State { result: "" }
    }

    pub fn visit_expression_statement(node: &ExpressionStatement) {
        let expr = &node.expression;

        // Basic is pattern with binding
        if expr is Expression::Identifier id {
            self.state.result = id.name.clone();
        }

        // is pattern without binding (just type check)
        if expr is Expression::CallExpression {
            self.state.result = "call";
        }

        // is pattern with reference
        if &node.expression is Expression::MemberExpression mem {
            self.state.result = "member";
        }

        // Nested in else-if
        if expr is Expression::Identifier id {
            self.state.result = id.name.clone();
        } else if expr is Expression::Literal lit {
            self.state.result = "literal".to_string();
        } else if expr is Expression::CallExpression call {
            self.state.result = "call".to_string();
        }

        // is pattern in match-like chains
        if expr is Expression::BinaryExpression bin {
            if &bin.left is Expression::Identifier left_id {
                if &bin.right is Expression::Literal right_lit {
                    self.state.result = format!("{} op lit", left_id.name);
                }
            }
        }
    }

    fn finish() -> Str {
        self.state.result
    }
}