mruby-mruby/mrbgems/mruby-compiler/core/node.h

/*
** node.h - nodes of abstract syntax tree
**
** See Copyright Notice in mruby.h
*/

#ifndef MRUBY_COMPILER_NODE_H
#define MRUBY_COMPILER_NODE_H

enum node_type {
  NODE_SCOPE,
  NODE_BLOCK,
  NODE_IF,
  NODE_CASE,
  NODE_WHILE,
  NODE_UNTIL,
  NODE_WHILE_MOD,
  NODE_UNTIL_MOD,
  NODE_FOR,
  NODE_BREAK,
  NODE_NEXT,
  NODE_REDO,
  NODE_RETRY,
  NODE_STMTS,
  NODE_BEGIN,
  NODE_RESCUE,
  NODE_ENSURE,
  NODE_AND,
  NODE_OR,
  NODE_NOT,
  NODE_MASGN,
  NODE_ASGN,
  NODE_OP_ASGN,
  NODE_CALL,
  NODE_SUPER,
  NODE_ZSUPER,
  NODE_ARRAY,
  NODE_ZARRAY,
  NODE_HASH,
  NODE_RETURN,
  NODE_YIELD,
  NODE_LVAR,
  NODE_DVAR,
  NODE_GVAR,
  NODE_IVAR,
  NODE_CONST,
  NODE_CVAR,
  NODE_NVAR,
  NODE_NTH_REF,
  NODE_BACK_REF,
  NODE_MATCH,
  NODE_INT,
  NODE_BIGINT,
  NODE_FLOAT,
  NODE_NEGATE,
  NODE_LAMBDA,
  NODE_SYM,
  NODE_STR,
  NODE_XSTR,
  NODE_REGX,
  NODE_DREGX,
  NODE_CALLARGS,
  NODE_SPLAT,
  NODE_TO_ARY,
  NODE_SVALUE,
  NODE_BLOCK_ARG,
  NODE_DEF,
  NODE_SDEF,
  NODE_ALIAS,
  NODE_UNDEF,
  NODE_CLASS,
  NODE_MODULE,
  NODE_SCLASS,
  NODE_COLON2,
  NODE_COLON3,
  NODE_DOT2,
  NODE_DOT3,
  NODE_SELF,
  NODE_NIL,
  NODE_TRUE,
  NODE_FALSE,
  NODE_DEFINED,
  NODE_POSTEXE,
  NODE_DSYM,
  NODE_HEREDOC,
  NODE_WORDS,
  NODE_SYMBOLS,
  NODE_LAST
};

#define STR_FUNC_PARSING 0x01
#define STR_FUNC_EXPAND  0x02
#define STR_FUNC_REGEXP  0x04
#define STR_FUNC_WORD    0x08
#define STR_FUNC_SYMBOL  0x10
#define STR_FUNC_ARRAY   0x20
#define STR_FUNC_HEREDOC 0x40
#define STR_FUNC_XQUOTE  0x80

enum mrb_string_type {
  str_not_parsing  = (0),
  str_squote   = (STR_FUNC_PARSING),
  str_dquote   = (STR_FUNC_PARSING|STR_FUNC_EXPAND),
  str_regexp   = (STR_FUNC_PARSING|STR_FUNC_REGEXP|STR_FUNC_EXPAND),
  str_sword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY),
  str_dword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
  str_ssym     = (STR_FUNC_PARSING|STR_FUNC_SYMBOL),
  str_ssymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY),
  str_dsymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
  str_heredoc  = (STR_FUNC_PARSING|STR_FUNC_HEREDOC),
  str_xquote   = (STR_FUNC_PARSING|STR_FUNC_XQUOTE|STR_FUNC_EXPAND),
};

/* heredoc structure */
struct mrb_parser_heredoc_info {
  mrb_bool allow_indent:1;
  mrb_bool remove_indent:1;
  mrb_bool line_head:1;
  size_t indent;
  mrb_ast_node *indented;
  enum mrb_string_type type;
  const char *term;
  int term_len;
  mrb_ast_node *doc;
};

/* AST node structures - Head-only location optimization */

/* Structure nodes - only car/cdr, ignores location fields */
struct mrb_ast_node {
  struct mrb_ast_node *car, *cdr;
  /* No location fields - saves 4 bytes per structure node */
};

/* Variable-sized AST nodes - Phase 1 Infrastructure */

/* Variable node header - common to all variable-sized nodes */
struct mrb_ast_var_header {
  uint16_t lineno;           /* Line number information */
  uint16_t filename_index;   /* File index information */
  uint8_t node_type;         /* NODE_INT, NODE_SYM, NODE_STR, etc. */
  /* Total: 6 bytes header for all variable nodes */
};

/* Phase 1 Variable Node Structures */

/* Variable-sized symbol node */
struct mrb_ast_sym_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  mrb_sym symbol;                    /* Direct symbol reference */
  /* Total: 12-16 bytes vs previous 20+ bytes + indirection */
};

/* Variable-sized string node with cons list */
struct mrb_ast_str_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *list;
};

/* Variable-sized integer node */
struct mrb_ast_int_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  int32_t value;                     /* Direct 32-bit integer storage */
};

/* Variable-sized big integer node */
struct mrb_ast_bigint_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  char *string;                      /* String representation of big number */
  int base;                          /* Number base (8, 10, 16) */
};

/* Variable-sized node for variables (lvar, ivar, etc.) */
struct mrb_ast_var_node {
  struct mrb_ast_var_header header;
  mrb_sym symbol;
};

/* Phase 2 Variable Node Structures */

/* Variable-sized call node with inline argument storage */
struct mrb_ast_call_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *receiver;     /* Receiver object */
  mrb_sym method_name;               /* Method name symbol */
  uint8_t argc;                      /* Number of regular arguments */
  uint8_t has_kwargs:1;              /* Has keyword arguments */
  uint8_t has_block:1;               /* Has block argument */
  uint8_t safe_call:1;               /* Safe navigation (&.) */
  uint8_t reserved:5;                /* Reserved for future flags */
  struct mrb_ast_node *args;         /* Arguments Information */
};

/* Variable-sized array node - revert to original cons list approach */
struct mrb_ast_array_node {
  struct mrb_ast_var_header header;    /* 8 bytes */
  struct mrb_ast_node *elements;       /* Original elements list */
};

/* Variable-sized hash node - revert to original cons list approach */
struct mrb_ast_hash_node {
  struct mrb_ast_var_header header;    /* 8 bytes */
  struct mrb_ast_node *pairs;          /* Original pairs list */
};

/* Phase 3 Variable Node Structures - Control Flow */

/* Variable-sized method definition node */
struct mrb_ast_def_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  mrb_sym name;                      /* Method name */
  struct mrb_ast_args *args;         /* Method arguments */
  struct mrb_ast_node *body;         /* Method body */
  struct mrb_ast_node *locals;       /* Local Variables */
} ;

/* Variable-sized singleton method definition node */
struct mrb_ast_sdef_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  mrb_sym name;                      /* Method name */
  struct mrb_ast_args *args;         /* Method arguments */
  struct mrb_ast_node *body;         /* Method body */
  struct mrb_ast_node *locals;       /* Local Variables */
  struct mrb_ast_node *obj;          /* receiver */
};

/* variable-sized class definition node */
struct mrb_ast_class_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *name;         /* Class name (NODE_CONST or NODE_COLON2) */
  struct mrb_ast_node *superclass;   /* Superclass (can be NULL) */
  struct mrb_ast_node *body;         /* Class body */
};

/* Variable-sized module definition node */
struct mrb_ast_module_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *name;         /* Module name (NODE_CONST or NODE_COLON2) */
  struct mrb_ast_node *body;         /* Module body */
};

/* Variable-sized singleton class definition node */
struct mrb_ast_sclass_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *obj;          /* Object for singleton class */
  struct mrb_ast_node *body;         /* Singleton class body */
};

/* Variable-sized if node */
struct mrb_ast_if_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *condition;    /* Condition expression */
  struct mrb_ast_node *then_body;    /* Then branch */
  struct mrb_ast_node *else_body;    /* Else branch (can be NULL) */
};

/* Variable-sized while node */
struct mrb_ast_while_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *condition;    /* Loop condition */
  struct mrb_ast_node *body;         /* Loop body */
};

/* Variable-sized until node */
struct mrb_ast_until_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *condition;    /* Loop condition */
  struct mrb_ast_node *body;         /* Loop body */
};

/* Variable-sized case node - revert to original cons list approach */
struct mrb_ast_case_node {
  struct mrb_ast_var_header header;    /* 8 bytes */
  struct mrb_ast_node *value;          /* Case value expression */
  struct mrb_ast_node *body;           /* Original when/else body list */
};

/* Variable-sized for node */
struct mrb_ast_for_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *var;          /* Loop variable */
  struct mrb_ast_node *iterable;     /* Object to iterate over */
  struct mrb_ast_node *body;         /* Loop body */
};

/* Assignment Node Structures */

/* Variable-sized assignment node */
struct mrb_ast_asgn_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *lhs;          /* Left-hand side (target) */
  struct mrb_ast_node *rhs;          /* Right-hand side (value) */
};

/* Variable-sized multiple assignment node */
struct mrb_ast_masgn_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *lhs;          /* Left-hand side (multiple targets) */
  struct mrb_ast_node *rhs;          /* Right-hand side (values) */
};

/* Variable-sized operator assignment node */
struct mrb_ast_op_asgn_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *lhs;          /* Left-hand side (target) */
  mrb_sym op;                        /* Assignment operator (e.g., +=, -=, etc.) */
  struct mrb_ast_node *rhs;          /* Right-hand side (value) */
};

/* Expression Node Structures */

/* Variable-sized AND node */
struct mrb_ast_and_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *left;         /* Left operand */
  struct mrb_ast_node *right;        /* Right operand */
};

/* Variable-sized OR node */
struct mrb_ast_or_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *left;         /* Left operand */
  struct mrb_ast_node *right;        /* Right operand */
};

/* Variable-sized RETURN node */
struct mrb_ast_return_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *args;         /* Return arguments (can be NULL) */
};

/* Variable-sized YIELD node */
struct mrb_ast_yield_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *args;         /* Yield arguments (can be NULL) */
};

/* Variable-sized SUPER node */
struct mrb_ast_super_node {
  struct mrb_ast_var_header header;  /* 8 bytes */
  struct mrb_ast_node *args;         /* Super arguments (can be NULL) */
};

/* String storage strategy thresholds */
#define STR_INLINE_THRESHOLD  48   /* Inline strings <= 48 bytes */
#define STR_SMALL_THRESHOLD   128  /* Small strings <= 128 bytes */

#define VAR_NODE_TYPE(n) ((enum node_type)(((struct mrb_ast_var_header*)(n))->node_type))

/* Type-safe casting macros */
#define var_header(n) ((struct mrb_ast_var_header*)(n))

/* Common type casting macros used by parser and codegen */
#define node_to_sym(x) ((mrb_sym)(intptr_t)(x))
#define sym_to_node(x) ((node*)(intptr_t)(x))
#define int_to_node(x) ((node*)(intptr_t)(x))
#define node_to_int(x) ((int)(intptr_t)(x))
#define node_to_type(x) ((enum node_type)(intptr_t)(x))
#define node_to_char(x) ((char)(intptr_t)(x))

/* Phase 1 node casting macros */
#define sym_node(n) ((struct mrb_ast_sym_node*)(n))
#define str_node(n) ((struct mrb_ast_str_node*)(n))
#define int_node(n) ((struct mrb_ast_int_node*)(n))
#define bigint_node(n) ((struct mrb_ast_bigint_node*)(n))
#define var_node(n) ((struct mrb_ast_var_node*)(n))

/* Phase 2 node casting macros */
#define call_node(n) ((struct mrb_ast_call_node*)(n))
#define array_node(n) ((struct mrb_ast_array_node*)(n))
#define hash_node(n) ((struct mrb_ast_hash_node*)(n))

/* Phase 3 node casting macros */
#define def_node(n) ((struct mrb_ast_def_node*)(n))
#define class_node(n) ((struct mrb_ast_class_node*)(n))
#define module_node(n) ((struct mrb_ast_module_node*)(n))
#define sclass_node(n) ((struct mrb_ast_sclass_node*)(n))
#define if_node(n) ((struct mrb_ast_if_node*)(n))
#define while_node(n) ((struct mrb_ast_while_node*)(n))
#define until_node(n) ((struct mrb_ast_until_node*)(n))
#define case_node(n) ((struct mrb_ast_case_node*)(n))
#define for_node(n) ((struct mrb_ast_for_node*)(n))
#define asgn_node(n) ((struct mrb_ast_asgn_node*)(n))
#define masgn_node(n) ((struct mrb_ast_masgn_node*)(n))
#define op_asgn_node(n) ((struct mrb_ast_op_asgn_node*)(n))
#define and_node(n) ((struct mrb_ast_and_node*)(n))
#define or_node(n) ((struct mrb_ast_or_node*)(n))
#define return_node(n) ((struct mrb_ast_return_node*)(n))
#define yield_node(n) ((struct mrb_ast_yield_node*)(n))
#define super_node(n) ((struct mrb_ast_super_node*)(n))

/* Phase 1 value access macros */
#define SYM_NODE_VALUE(n) (sym_node(n)->symbol)
#define STR_NODE_PTR(n) (str_node(n)->data)
#define STR_NODE_LEN(n) (str_node(n)->len)
#define INT_NODE_VALUE(n) (int_node(n)->value)
#define BIGINT_NODE_STRING(n) (bigint_node(n)->string)
#define BIGINT_NODE_BASE(n) (bigint_node(n)->base)
#define VAR_NODE_SYMBOL(n) (var_node(n)->symbol)

/* Phase 2 value access macros */
#define CALL_NODE_RECEIVER(n) (call_node(n)->receiver)
#define CALL_NODE_METHOD(n) (call_node(n)->method_name)
#define CALL_NODE_ARGC(n) (call_node(n)->argc)
#define CALL_NODE_ARGS(n) (call_node(n)->args)
#define CALL_NODE_HAS_KWARGS(n) (call_node(n)->has_kwargs)
#define CALL_NODE_HAS_BLOCK(n) (call_node(n)->has_block)
#define CALL_NODE_SAFE(n) (call_node(n)->safe_call)

#define ARRAY_NODE_ELEMENTS(n) (array_node(n)->elements)

#define HASH_NODE_PAIRS(n) (hash_node(n)->pairs)

/* Phase 3 value access macros */
#define IF_NODE_CONDITION(n) (if_node(n)->condition)
#define IF_NODE_THEN(n) (if_node(n)->then_body)
#define IF_NODE_ELSE(n) (if_node(n)->else_body)

#define WHILE_NODE_CONDITION(n) (while_node(n)->condition)
#define WHILE_NODE_BODY(n) (while_node(n)->body)

#define UNTIL_NODE_CONDITION(n) (until_node(n)->condition)
#define UNTIL_NODE_BODY(n) (until_node(n)->body)

#define CASE_NODE_VALUE(n) (case_node(n)->value)
#define CASE_NODE_BODY(n) (case_node(n)->body)

#define FOR_NODE_VAR(n) (for_node(n)->var)
#define FOR_NODE_ITERABLE(n) (for_node(n)->iterable)
#define FOR_NODE_BODY(n) (for_node(n)->body)

/* Definition node value access macros */
#define DEF_NODE_NAME(n) (def_node(n)->name)
#define DEF_NODE_ARGS(n) (def_node(n)->args)
#define DEF_NODE_BODY(n) (def_node(n)->body)
#define DEF_NODE_LOCALS(n) (def_node(n)->locals)
#define SDEF_NODE_NAME(n) (sdef_node(n)->name)
#define SDEF_NODE_ARGS(n) (sdef_node(n)->args)
#define SDEF_NODE_BODY(n) (sdef_node(n)->body)
#define SDEF_NODE_LOCALS(n) (sdef_node(n)->locals)
#define SDEF_NODE_OBJ(n) (sdef_node(n)->body)
#define CLASS_NODE_NAME(n) (class_node(n)->name)
#define CLASS_NODE_SUPERCLASS(n) (class_node(n)->superclass)
#define CLASS_NODE_BODY(n) (class_node(n)->body)

#define MODULE_NODE_NAME(n) (module_node(n)->name)
#define MODULE_NODE_BODY(n) (module_node(n)->body)

#define SCLASS_NODE_OBJ(n) (sclass_node(n)->obj)
#define SCLASS_NODE_BODY(n) (sclass_node(n)->body)

/* Assignment node value access macros */
#define ASGN_NODE_LHS(n) (asgn_node(n)->lhs)
#define ASGN_NODE_RHS(n) (asgn_node(n)->rhs)

#define MASGN_NODE_LHS(n) (masgn_node(n)->lhs)
#define MASGN_NODE_RHS(n) (masgn_node(n)->rhs)

#define OP_ASGN_NODE_LHS(n) (op_asgn_node(n)->lhs)
#define OP_ASGN_NODE_OP(n) (op_asgn_node(n)->op)
#define OP_ASGN_NODE_RHS(n) (op_asgn_node(n)->rhs)

/* Expression node value access macros */
#define AND_NODE_LEFT(n) (and_node(n)->left)
#define AND_NODE_RIGHT(n) (and_node(n)->right)

#define OR_NODE_LEFT(n) (or_node(n)->left)
#define OR_NODE_RIGHT(n) (or_node(n)->right)

#define RETURN_NODE_ARGS(n) (return_node(n)->args)
#define YIELD_NODE_ARGS(n) (yield_node(n)->args)
#define SUPER_NODE_ARGS(n) (super_node(n)->args)

/* Variable-sized literal node structures */

struct mrb_ast_regx_node {
  struct mrb_ast_var_header header;
  const char *pattern;
  int pattern_len;
  const char *flags;
  const char *encoding;
};

struct mrb_ast_dot2_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *left;
  struct mrb_ast_node *right;
};

struct mrb_ast_dot3_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *left;
  struct mrb_ast_node *right;
};

struct mrb_ast_float_node {
  struct mrb_ast_var_header header;
  const char *value;
};

/* Literal node casting macros */
#define regx_node(n) ((struct mrb_ast_regx_node*)(n))
#define dot2_node(n) ((struct mrb_ast_dot2_node*)(n))
#define dot3_node(n) ((struct mrb_ast_dot3_node*)(n))
#define float_node(n) ((struct mrb_ast_float_node*)(n))

/* Literal node value access macros */
#define STR_NODE_LIST(n) (str_node(n)->list)

#define REGX_NODE_PATTERN(n) (regx_node(n)->pattern)
#define REGX_NODE_FLAGS(n) (regx_node(n)->flags)
#define REGX_NODE_ENCODING(n) (regx_node(n)->encoding)

#define DOT2_NODE_LEFT(n) (dot2_node(n)->left)
#define DOT2_NODE_RIGHT(n) (dot2_node(n)->right)

#define DOT3_NODE_LEFT(n) (dot3_node(n)->left)
#define DOT3_NODE_RIGHT(n) (dot3_node(n)->right)

#define FLOAT_NODE_VALUE(n) (float_node(n)->value)

/* Variable-sized simple node structures */
struct mrb_ast_self_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_nil_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_true_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_false_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_const_node {
  struct mrb_ast_var_header header;
  mrb_sym symbol;
};

/* Simple node casting macros */
#define self_node(n) ((struct mrb_ast_self_node*)(n))
#define nil_node(n) ((struct mrb_ast_nil_node*)(n))
#define true_node(n) ((struct mrb_ast_true_node*)(n))
#define false_node(n) ((struct mrb_ast_false_node*)(n))
#define const_node(n) ((struct mrb_ast_const_node*)(n))

/* Simple node value access macros */
#define CONST_NODE_SYMBOL(n) (const_node(n)->symbol)

/* Variable-sized advanced node structures */
struct mrb_ast_rescue_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *body;
  struct mrb_ast_node *rescue_clauses;
  struct mrb_ast_node *else_clause;
};

struct mrb_ast_block_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *locals;
  struct mrb_ast_args *args;
  struct mrb_ast_node *body;
};

/* Unified argument structure - eliminates args_tail_node allocation */
struct mrb_ast_args {
  /* Core argument lists (parser builds these naturally) */
  struct mrb_ast_node *mandatory_args;      /* Cons list of mandatory arguments */
  struct mrb_ast_node *optional_args;       /* Cons list of optional arguments */
  struct mrb_ast_node *post_mandatory_args; /* Cons list of post-mandatory arguments */
  struct mrb_ast_node *keyword_args;        /* Cons list of keyword arguments */

  /* Special arguments (directly embedded) */
  mrb_sym rest_arg;                         /* Rest argument symbol (0 = none) */
  mrb_sym kwrest_arg;                       /* Keyword rest argument (0 = none) */
  mrb_sym block_arg;                        /* Block argument symbol (0 = none) */
};

/* Call arguments structure - replaces cons-based new_callargs */
struct mrb_ast_callargs {
  struct mrb_ast_node *regular_args;    /* Cons list of regular arguments (preserves splat compatibility) */
  struct mrb_ast_node *keyword_args;    /* Keyword arguments hash node */
  struct mrb_ast_node *block_arg;       /* Block argument node */
};

/* Advanced node casting macros */
#define rescue_node(n) ((struct mrb_ast_rescue_node*)(n))
#define block_node(n) ((struct mrb_ast_block_node*)(n))
#define callargs_node(n) ((struct mrb_ast_callargs*)(n))

/* Advanced node value access macros */
#define RESCUE_NODE_BODY(n) (rescue_node(n)->body)
#define RESCUE_NODE_RESCUE_CLAUSES(n) (rescue_node(n)->rescue_clauses)
#define RESCUE_NODE_ELSE_CLAUSE(n) (rescue_node(n)->else_clause)

#define BLOCK_NODE_LOCALS(n) (block_node(n)->locals)
#define BLOCK_NODE_ARGS(n) (block_node(n)->args)
#define BLOCK_NODE_BODY(n) (block_node(n)->body)

#define ARGS_NODE_MANDATORY(n) (args_node(n)->mandatory)
#define ARGS_NODE_OPTIONAL(n) (args_node(n)->optional)
#define ARGS_NODE_REST(n) (args_node(n)->rest)
#define ARGS_NODE_MANDATORY_AFTER_REST(n) (args_node(n)->mandatory_after_rest)
#define ARGS_NODE_TAIL(n) (args_node(n)->tail)

#define ARGS_TAIL_NODE_KEYWORDS(n) (args_tail_node(n)->keywords)
#define ARGS_TAIL_NODE_KWREST(n) (args_tail_node(n)->kwrest)
#define ARGS_TAIL_NODE_BLOCK(n) (args_tail_node(n)->block)

#define CALLARGS_NODE_REGULAR(n) (callargs_node(n)->regular_args)
#define CALLARGS_NODE_KEYWORDS(n) (callargs_node(n)->keyword_args)
#define CALLARGS_NODE_BLOCK(n) (callargs_node(n)->block_arg)

// Group 8: Control Flow Statements
struct mrb_ast_break_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

struct mrb_ast_next_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

struct mrb_ast_redo_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_retry_node {
  struct mrb_ast_var_header header;
};

#define break_node(n) ((struct mrb_ast_break_node*)(n))
#define next_node(n) ((struct mrb_ast_next_node*)(n))
#define redo_node(n) ((struct mrb_ast_redo_node*)(n))
#define retry_node(n) ((struct mrb_ast_retry_node*)(n))
#define BREAK_NODE_VALUE(n) (break_node(n)->value)
#define NEXT_NODE_VALUE(n) (next_node(n)->value)

// Group 9: String and Regex Variants
struct mrb_ast_xstr_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *list;
};

struct mrb_ast_dregx_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *list;
  const char *flags;
  const char *encoding;
};


struct mrb_ast_heredoc_node {
  struct mrb_ast_var_header header;
  struct mrb_parser_heredoc_info info;
};

struct mrb_ast_dsym_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *list;
};

#define xstr_node(n) ((struct mrb_ast_xstr_node*)(n))
#define dregx_node(n) ((struct mrb_ast_dregx_node*)(n))
#define heredoc_node(n) ((struct mrb_ast_heredoc_node*)(n))
#define dsym_node(n) ((struct mrb_ast_dsym_node*)(n))

#define XSTR_NODE_LIST(n) (xstr_node(n)->list)
#define DREGX_NODE_LIST(n) (dregx_node(n)->list)
#define DREGX_NODE_OPTIONS(n) (dregx_node(n)->options)
#define HEREDOC_NODE_NAME(n) (heredoc_node(n)->name)
#define DSYM_NODE_LIST(n) (dsym_node(n)->list)

// Group 10: References and Variables
struct mrb_ast_nth_ref_node {
  struct mrb_ast_var_header header;
  int nth;
};

struct mrb_ast_back_ref_node {
  struct mrb_ast_var_header header;
  int type;
};

struct mrb_ast_nvar_node {
  struct mrb_ast_var_header header;
  int num;
};

struct mrb_ast_dvar_node {
  struct mrb_ast_var_header header;
  mrb_sym name;
};

struct mrb_ast_match_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *pattern;
};

#define nth_ref_node(n) ((struct mrb_ast_nth_ref_node*)(n))
#define back_ref_node(n) ((struct mrb_ast_back_ref_node*)(n))
#define nvar_node(n) ((struct mrb_ast_nvar_node*)(n))
#define dvar_node(n) ((struct mrb_ast_dvar_node*)(n))
#define match_node(n) ((struct mrb_ast_match_node*)(n))

#define NTH_REF_NODE_NTH(n) (nth_ref_node(n)->nth)
#define BACK_REF_NODE_TYPE(n) (back_ref_node(n)->type)
#define NVAR_NODE_NUM(n) (nvar_node(n)->num)
#define DVAR_NODE_NAME(n) (dvar_node(n)->name)
#define MATCH_NODE_PATTERN(n) (match_node(n)->pattern)

// Group 11: Operators and Expressions
struct mrb_ast_not_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *operand;
};

struct mrb_ast_negate_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *operand;
};

struct mrb_ast_colon2_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *base;
  mrb_sym name;
};

struct mrb_ast_colon3_node {
  struct mrb_ast_var_header header;
  mrb_sym name;
};

struct mrb_ast_defined_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *expr;
};

#define not_node(n) ((struct mrb_ast_not_node*)(n))
#define negate_node(n) ((struct mrb_ast_negate_node*)(n))
#define colon2_node(n) ((struct mrb_ast_colon2_node*)(n))
#define colon3_node(n) ((struct mrb_ast_colon3_node*)(n))
#define defined_node(n) ((struct mrb_ast_defined_node*)(n))

#define NOT_NODE_OPERAND(n) (not_node(n)->operand)
#define NEGATE_NODE_OPERAND(n) (negate_node(n)->operand)
#define COLON2_NODE_BASE(n) (colon2_node(n)->base)
#define COLON2_NODE_NAME(n) (colon2_node(n)->name)
#define COLON3_NODE_NAME(n) (colon3_node(n)->name)
#define DEFINED_NODE_EXPR(n) (defined_node(n)->expr)

// Group 12: Function Calls and Special Forms
struct mrb_ast_lambda_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *locals;
  struct mrb_ast_args *args;
  struct mrb_ast_node *body;
};

// Group 13: Containers and Collections
struct mrb_ast_zarray_node {
  struct mrb_ast_var_header header;
};

struct mrb_ast_words_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *args;
};

struct mrb_ast_symbols_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *args;
};

// Group 14: Arguments and Parameters

struct mrb_ast_splat_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

struct mrb_ast_to_ary_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

struct mrb_ast_svalue_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

struct mrb_ast_block_arg_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *value;
};

// Group 15: Structural Nodes
struct mrb_ast_method_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *body;
};

struct mrb_ast_scope_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *locals;
  struct mrb_ast_node *body;
};

struct mrb_ast_begin_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *body;
};

struct mrb_ast_ensure_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *body;
  struct mrb_ast_node *ensure_clause;
};

struct mrb_ast_stmts_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *stmts;        /* Cons-list of statements */
};

struct mrb_ast_iter_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *vars;
  struct mrb_ast_node *body;
};

struct mrb_ast_when_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *cond;
  struct mrb_ast_node *body;
  struct mrb_ast_node *next_when;
};

// Group 16: Declarations and Definitions

struct mrb_ast_alias_node {
  struct mrb_ast_var_header header;
  mrb_sym new_name;
  mrb_sym old_name;
};

struct mrb_ast_undef_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *syms;
};

struct mrb_ast_postexe_node {
  struct mrb_ast_var_header header;
  struct mrb_ast_node *body;
};

#define zsuper_node(n) ((struct mrb_ast_super_node*)(n))
#define lambda_node(n) ((struct mrb_ast_lambda_node*)(n))
#define zarray_node(n) ((struct mrb_ast_zarray_node*)(n))
#define words_node(n) ((struct mrb_ast_words_node*)(n))
#define symbols_node(n) ((struct mrb_ast_symbols_node*)(n))
#define splat_node(n) ((struct mrb_ast_splat_node*)(n))
#define to_ary_node(n) ((struct mrb_ast_to_ary_node*)(n))
#define svalue_node(n) ((struct mrb_ast_svalue_node*)(n))
#define block_arg_node(n) ((struct mrb_ast_block_arg_node*)(n))
#define method_node(n) ((struct mrb_ast_method_node*)(n))
#define scope_node(n) ((struct mrb_ast_scope_node*)(n))
#define begin_node(n) ((struct mrb_ast_begin_node*)(n))
#define ensure_node(n) ((struct mrb_ast_ensure_node*)(n))
#define stmts_node(n) ((struct mrb_ast_stmts_node*)(n))
#define iter_node(n) ((struct mrb_ast_iter_node*)(n))
#define when_node(n) ((struct mrb_ast_when_node*)(n))
#define alias_node(n) ((struct mrb_ast_alias_node*)(n))
#define undef_node(n) ((struct mrb_ast_undef_node*)(n))
#define postexe_node(n) ((struct mrb_ast_postexe_node*)(n))
#define sdef_node(n) ((struct mrb_ast_sdef_node*)(n))

#define LAMBDA_NODE_LOCALS(n) (lambda_node(n)->locals)
#define LAMBDA_NODE_ARGS(n) (lambda_node(n)->args)
#define LAMBDA_NODE_BODY(n) (lambda_node(n)->body)
#define WORDS_NODE_ARGS(n) (words_node(n)->args)
#define SYMBOLS_NODE_ARGS(n) (symbols_node(n)->args)
#define SPLAT_NODE_VALUE(n) (splat_node(n)->value)
#define TO_ARY_NODE_VALUE(n) (to_ary_node(n)->value)
#define SVALUE_NODE_VALUE(n) (svalue_node(n)->value)
#define BLOCK_ARG_NODE_VALUE(n) (block_arg_node(n)->value)
#define METHOD_NODE_BODY(n) (method_node(n)->body)
#define SCOPE_NODE_LOCALS(n) (scope_node(n)->locals)
#define SCOPE_NODE_BODY(n) (scope_node(n)->body)
#define STMTS_NODE_STMTS(n) (stmts_node(n)->stmts)
#define BEGIN_NODE_BODY(n) (begin_node(n)->body)
#define ENSURE_NODE_BODY(n) (ensure_node(n)->body)
#define ENSURE_NODE_ENSURE_CLAUSE(n) (ensure_node(n)->ensure_clause)
#define ITER_NODE_VARS(n) (iter_node(n)->vars)
#define ITER_NODE_BODY(n) (iter_node(n)->body)
#define WHEN_NODE_COND(n) (when_node(n)->cond)
#define WHEN_NODE_BODY(n) (when_node(n)->body)
#define WHEN_NODE_NEXT_WHEN(n) (when_node(n)->next_when)

#endif  /* MRUBY_COMPILER_NODE_H */