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
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

//! Visitor Method Generation
//!
//! This module generates visitor methods for SWC's VisitMut/Visit traits.

use super::SwcGenerator;
use crate::parser::*;
use crate::codegen::swc_decorator::*;
use crate::codegen::decorated_ast::*;

impl SwcGenerator {
    pub(super) fn is_visitor_method(&self, f: &FnDecl) -> bool {
        // Must be named visit_*
        if !f.name.starts_with("visit_") {
            return false;
        }

        // Must have no return type
        if f.return_type.is_some() {
            return false;
        }

        // Must have at least one parameter that is a mutable reference
        if let Some(first_param) = f.params.first() {
            if let Type::Reference { mutable, .. } = &first_param.ty {
                return *mutable;
            }
        }

        false
    }
    pub(super) fn gen_decorated_visitor_method(&mut self, func: &DecoratedFnDecl) {
        // Generate visitor method using decorated AST (metadata-driven!)
        let swc_name = self.visitor_name_to_swc(&func.name);
        let swc_type = self.visitor_name_to_swc_type(&func.name);

        self.emit_line("");
        self.emit_line(&format!("fn {}(&mut self, n: &mut {}) {{", swc_name, swc_type));
        self.indent += 1;

        // Store parameter rename (e.g., "node" -> "n")
        for param in &func.params {
            self.param_renames.insert(param.name.clone(), "n".to_string());
        }

        // Generate function body from decorated AST
        self.gen_decorated_block(&func.body);

        // Clean up parameter renames
        for param in &func.params {
            self.param_renames.remove(&param.name);
        }

        self.indent -= 1;
        self.emit_line("}");
    }
    pub(super) fn gen_visitor_method(&mut self, f: &FnDecl) {
        let swc_name = self.visitor_name_to_swc(&f.name);
        let swc_type = self.visitor_name_to_swc_type(&f.name);

        self.emit_line("");
        self.emit_line(&format!("fn {}(&mut self, n: &mut {}) {{", swc_name, swc_type));
        self.indent += 1;

        // Set up parameter renames for visitor methods
        // The first parameter (typically "node") maps to "n"
        if let Some(first_param) = f.params.first() {
            self.param_renames.insert(first_param.name.clone(), "n".to_string());
        }

        // Track the parameter's type in the environment
        // Both "n" and the original parameter name should map to the swc_type
        self.type_env.push_scope();
        let param_ctx = TypeContext {
            reluxscript_type: swc_type.clone(),
            swc_type: swc_type.clone(),
            kind: super::type_context::SwcTypeKind::Struct,
            known_variant: None,
            needs_deref: false,
        };
        self.type_env.define("n", param_ctx.clone());
        if let Some(first_param) = f.params.first() {
            self.type_env.define(&first_param.name, param_ctx);
        }

        // Generate body
        self.gen_block(&f.body);

        // Clear environment and renames
        self.type_env.pop_scope();
        self.param_renames.clear();

        self.indent -= 1;
        self.emit_line("}");
    }
    pub(super) fn gen_visit_method(&mut self, f: &FnDecl) {
        // For Visit (read-only), parameters are & not &mut
        let mut swc_name = self.visitor_name_to_swc(&f.name);
        // Convert visit_mut_ to visit_ for Visit trait
        if swc_name.starts_with("visit_mut_") {
            swc_name = swc_name.replace("visit_mut_", "visit_");
        }
        let swc_type = self.visitor_name_to_swc_type(&f.name);

        self.emit_line("");
        self.emit_line(&format!("fn {}(&mut self, n: &{}) {{", swc_name, swc_type));
        self.indent += 1;

        // Set up parameter renames for visitor methods
        // The first parameter (typically "node") maps to "n"
        if let Some(first_param) = f.params.first() {
            self.param_renames.insert(first_param.name.clone(), "n".to_string());
        }

        // Track the parameter's type in the environment
        // Both "n" and the original parameter name should map to the swc_type
        self.type_env.push_scope();
        let param_ctx = TypeContext {
            reluxscript_type: swc_type.clone(),
            swc_type: swc_type.clone(),
            kind: super::type_context::SwcTypeKind::Struct,
            known_variant: None,
            needs_deref: false,
        };
        self.type_env.define("n", param_ctx.clone());
        if let Some(first_param) = f.params.first() {
            self.type_env.define(&first_param.name, param_ctx);
        }

        // Generate body - for visitor methods, all statements should have semicolons
        // (they return (), not an implicit value)
        for stmt in &f.body.stmts {
            self.gen_stmt(stmt);
        }

        // Clear environment and renames
        self.type_env.pop_scope();
        self.param_renames.clear();

        self.indent -= 1;
        self.emit_line("}");
    }
}