Node Constructors

API for creating new AST nodes in ReluxScript.

Basic Constructors

Identifier

let id = Identifier::new("myVar");

String Literal

let str = StringLiteral::new("hello");

Numeric Literal

let num = NumericLiteral::new(42);

Boolean Literal

let bool_true = BooleanLiteral::new(true);
let bool_false = BooleanLiteral::new(false);

Expression Constructors

Call Expression

let call = CallExpression {
    callee: Identifier::new("console.log"),
    arguments: vec![StringLiteral::new("message")],
};

Member Expression

let member = MemberExpression {
    object: Identifier::new("console"),
    property: Identifier::new("log"),
    computed: false,
};

Binary Expression

let binary = BinaryExpression {
    left: Identifier::new("a"),
    operator: "+",
    right: Identifier::new("b"),
};

Arrow Function

let arrow = ArrowFunctionExpression {
    params: vec![Pattern::Identifier(Identifier::new("x"))],
    body: Expression::BinaryExpression(BinaryExpression {
        left: Identifier::new("x"),
        operator: "*",
        right: NumericLiteral::new(2),
    }),
    async: false,
};

Statement Constructors

Empty Statement

let empty = Statement::empty();

Expression Statement

let expr_stmt = Statement::expression(call_expression);

Return Statement

let ret = ReturnStatement {
    argument: Some(Identifier::new("value")),
};

Variable Declaration

let var_decl = VariableDeclaration {
    kind: "const",
    declarations: vec![
        VariableDeclarator {
            id: Pattern::Identifier(Identifier::new("x")),
            init: Some(NumericLiteral::new(42)),
        }
    ],
};

Collection Constructors

Array Expression

let arr = ArrayExpression {
    elements: vec![
        Some(NumericLiteral::new(1)),
        Some(NumericLiteral::new(2)),
        Some(NumericLiteral::new(3)),
    ],
};

Object Expression

let obj = ObjectExpression {
    properties: vec![
        ObjectProperty {
            key: Identifier::new("name"),
            value: StringLiteral::new("John"),
        },
        ObjectProperty {
            key: Identifier::new("age"),
            value: NumericLiteral::new(30),
        },
    ],
};

Helper Methods

Clone Node

let new_node = node.clone();

Check Node Type

if node.is_identifier() { }
if node.is_call_expression() { }

Get Node Type

let node_type = node.type_name();  // Returns "Identifier", "CallExpression", etc.

Common Patterns

Create Function Call

fn create_call(fn_name: &str, args: Vec<Expression>) -> CallExpression {
    CallExpression {
        callee: Identifier::new(fn_name),
        arguments: args,
    }
}

Create Constant Declaration

fn create_const(name: &str, value: Expression) -> VariableDeclaration {
    VariableDeclaration {
        kind: "const",
        declarations: vec![
            VariableDeclarator {
                id: Pattern::Identifier(Identifier::new(name)),
                init: Some(value),
            }
        ],
    }
}

Wrap in Block

fn wrap_in_block(statements: Vec<Statement>) -> BlockStatement {
    BlockStatement {
        body: statements,
    }
}

See Visitor Methods and Node Types for more.