mruby-compiler: rename class parameters to size_class for c++ compatibility

Rename all 'class' parameter and variable names to 'size_class' to avoid
conflict with C++ class keyword. This affects function parameters in
size_class_limit, parser_alloc_var, parser_free_var, and init_var_header,
as well as local variables in all new_* node creation functions.

Co-authored-by: Claude <noreply@anthropic.com>

mrbgems/mruby-compiler/core/parse.y

@@ -179,53 +179,53 @@ size_to_class(size_t size)
 
 /* Get maximum size for a size class */
 static inline size_t
-size_class_limit(enum mrb_ast_size_class class)
+size_class_limit(enum mrb_ast_size_class size_class)
 {
   static const size_t limits[] = SIZE_CLASS_LIMITS;
-  return (class < SIZE_CLASS_COUNT) ? limits[class] : 512;
+  return (size_class < SIZE_CLASS_COUNT) ? limits[size_class] : 512;
 }
 
 /* Allocate variable-sized node with size class management */
 static void*
-parser_alloc_var(parser_state *p, size_t size, enum mrb_ast_size_class class)
+parser_alloc_var(parser_state *p, size_t size, enum mrb_ast_size_class size_class)
 {
   /* Try to reuse from appropriate size class free list */
-  if (p->var_free_lists[class] && size <= size_class_limit(class)) {
-    struct mrb_ast_node *ptr = p->var_free_lists[class];
-    p->var_free_lists[class] = ptr->cdr;
-    p->var_alloc_counts[class]++;
+  if (p->var_free_lists[size_class] && size <= size_class_limit(size_class)) {
+    struct mrb_ast_node *ptr = p->var_free_lists[size_class];
+    p->var_free_lists[size_class] = ptr->cdr;
+    p->var_alloc_counts[size_class]++;
     return ptr;
   }
 
   /* Allocate new memory */
   void *ptr = parser_palloc(p, size);
   p->var_total_allocated += size;
-  p->var_alloc_counts[class]++;
+  p->var_alloc_counts[size_class]++;
   return ptr;
 }
 
 /* Free variable-sized node to appropriate size class list */
 /*
 static void
-parser_free_var(parser_state *p, void *ptr, enum mrb_ast_size_class class)
+parser_free_var(parser_state *p, void *ptr, enum mrb_ast_size_class size_class)
 {
   if (!ptr) return;
 
   struct mrb_ast_node *node = (struct mrb_ast_node*)ptr;
-  node->cdr = p->var_free_lists[class];
-  p->var_free_lists[class] = node;
+  node->cdr = p->var_free_lists[size_class];
+  p->var_free_lists[size_class] = node;
 }
 */
 
 /* Initialize variable node header */
 static void
 init_var_header(struct mrb_ast_var_header *header, parser_state *p,
-                enum node_type type, enum mrb_ast_size_class class)
+                enum node_type type, enum mrb_ast_size_class size_class)
 {
   header->lineno = p->lineno;
   header->filename_index = p->current_filename_index;
   header->node_type = (uint8_t)type;
-  header->size_class = (uint8_t)class;
+  header->size_class = (uint8_t)size_class;
   header->flags = 0;
 
   /* Handle file boundary edge case */
@@ -456,9 +456,9 @@ static node*
 new_scope(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_scope_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&scope_node->hdr, p, NODE_SCOPE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&scope_node->hdr, p, NODE_SCOPE, size_class);
   scope_node->locals = locals_node(p);
   scope_node->body = body;
   return cons_head((node*)NODE_VARIABLE, (node*)scope_node);
@@ -469,11 +469,11 @@ static node*
 new_stmts(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_stmts_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_STMTS, class);
+  init_var_header(&n->hdr, p, NODE_STMTS, size_class);
   n->stmts = body ? list1(body) : 0;  /* Wrap single statement in cons-list */
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -484,9 +484,9 @@ static node*
 new_begin(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_begin_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&begin_node->hdr, p, NODE_BEGIN, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&begin_node->hdr, p, NODE_BEGIN, size_class);
   begin_node->body = body;
   return cons_head((node*)NODE_VARIABLE, (node*)begin_node);
 }
@@ -498,11 +498,11 @@ static node*
 new_rescue(parser_state *p, node *body, node *resq, node *els)
 {
   size_t total_size = sizeof(struct mrb_ast_rescue_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_RESCUE, class);
+  init_var_header(&n->hdr, p, NODE_RESCUE, size_class);
   n->body = body;
   n->rescue_clauses = resq;
   n->else_clause = els;
@@ -521,9 +521,9 @@ static node*
 new_ensure(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_ensure_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&ensure_node->hdr, p, NODE_ENSURE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&ensure_node->hdr, p, NODE_ENSURE, size_class);
   ensure_node->body = a;
   ensure_node->ensure_clause = b;
   return cons_head((node*)NODE_VARIABLE, (node*)ensure_node);
@@ -534,11 +534,11 @@ static node*
 new_nil(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_nil_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_NIL, class);
+  init_var_header(&n->hdr, p, NODE_NIL, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -548,11 +548,11 @@ static node*
 new_true(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_true_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_TRUE, class);
+  init_var_header(&n->hdr, p, NODE_TRUE, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -562,11 +562,11 @@ static node*
 new_false(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_false_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_FALSE, class);
+  init_var_header(&n->hdr, p, NODE_FALSE, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -576,9 +576,9 @@ static node*
 new_alias(parser_state *p, mrb_sym a, mrb_sym b)
 {
   size_t total_size = sizeof(struct mrb_ast_alias_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&alias_node->hdr, p, NODE_ALIAS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&alias_node->hdr, p, NODE_ALIAS, size_class);
   alias_node->new_name = a;
   alias_node->old_name = b;
   return cons_head((node*)NODE_VARIABLE, (node*)alias_node);
@@ -591,11 +591,11 @@ new_if(parser_state *p, node *condition, node *then_body, node *else_body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_if_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_if_node *n;
 
-  n = (struct mrb_ast_if_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_IF, class);
+  n = (struct mrb_ast_if_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_IF, size_class);
   n->condition = condition;
   n->then_body = then_body;
   n->else_body = else_body;
@@ -610,11 +610,11 @@ new_while(parser_state *p, node *condition, node *body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_while_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_while_node *n;
 
-  n = (struct mrb_ast_while_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_WHILE, class);
+  n = (struct mrb_ast_while_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_WHILE, size_class);
   n->condition = condition;
   n->body = body;
 
@@ -628,11 +628,11 @@ new_until(parser_state *p, node *condition, node *body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_until_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_until_node *n;
 
-  n = (struct mrb_ast_until_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_UNTIL, class);
+  n = (struct mrb_ast_until_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_UNTIL, size_class);
   n->condition = condition;
   n->body = body;
 
@@ -666,11 +666,11 @@ new_for(parser_state *p, node *v, node *o, node *b)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_for_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_FOR, class);
+  init_var_header(&n->header, p, NODE_FOR, size_class);
   n->var = v;
   n->iterable = o;
   n->body = b;
@@ -698,9 +698,9 @@ static node*
 new_postexe(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_postexe_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&postexe_node->hdr, p, NODE_POSTEXE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&postexe_node->hdr, p, NODE_POSTEXE, size_class);
   postexe_node->body = a;
   return cons_head((node*)NODE_VARIABLE, (node*)postexe_node);
 }
@@ -710,11 +710,11 @@ static node*
 new_self(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_self_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_SELF, class);
+  init_var_header(&n->hdr, p, NODE_SELF, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -739,11 +739,11 @@ new_call(parser_state *p, node *receiver, mrb_sym method, node *args, int pass)
 
   /* Calculate size needed (fixed size now) */
   size_t total_size = sizeof(struct mrb_ast_call_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_CALL, class);
+  init_var_header(&n->header, p, NODE_CALL, size_class);
   n->receiver = receiver;
   n->method_name = method;
   n->argc = 0; /* argc will be determined at codegen time to handle splats */
@@ -778,11 +778,11 @@ static node*
 new_super(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_super_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_SUPER, class);
+  init_var_header(&n->header, p, NODE_SUPER, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -793,9 +793,9 @@ static node*
 new_zsuper(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_super_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_ZSUPER, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_ZSUPER, size_class);
   n->args = NULL;  /* zsuper initially has no args, but may be added by call_with_block */
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -809,11 +809,11 @@ new_yield(parser_state *p, node *c)
   }
 
   size_t total_size = sizeof(struct mrb_ast_yield_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_YIELD, class);
+  init_var_header(&n->header, p, NODE_YIELD, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -824,11 +824,11 @@ static node*
 new_return(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_return_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_RETURN, class);
+  init_var_header(&n->header, p, NODE_RETURN, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -839,9 +839,9 @@ static node*
 new_break(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_break_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_BREAK, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_BREAK, size_class);
   n->value = c;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -851,9 +851,9 @@ static node*
 new_next(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_next_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_NEXT, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_NEXT, size_class);
   n->value = c;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -863,9 +863,9 @@ static node*
 new_redo(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_redo_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_REDO, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_REDO, size_class);
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
 
@@ -874,9 +874,9 @@ static node*
 new_retry(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_retry_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_RETRY, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_RETRY, size_class);
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
 
@@ -885,11 +885,11 @@ static node*
 new_dot2(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_dot2_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_DOT2, class);
+  init_var_header(&n->hdr, p, NODE_DOT2, size_class);
   n->left = a;
   n->right = b;
 
@@ -901,11 +901,11 @@ static node*
 new_dot3(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_dot3_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_DOT3, class);
+  init_var_header(&n->hdr, p, NODE_DOT3, size_class);
   n->left = a;
   n->right = b;
 
@@ -919,9 +919,9 @@ new_colon2(parser_state *p, node *b, mrb_sym c)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_colon2_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&colon2_node->hdr, p, NODE_COLON2, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&colon2_node->hdr, p, NODE_COLON2, size_class);
   colon2_node->base = b;
   colon2_node->name = c;
   return cons_head((node*)NODE_VARIABLE, (node*)colon2_node);
@@ -932,9 +932,9 @@ static node*
 new_colon3(parser_state *p, mrb_sym c)
 {
   size_t total_size = sizeof(struct mrb_ast_colon3_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&colon3_node->hdr, p, NODE_COLON3, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&colon3_node->hdr, p, NODE_COLON3, size_class);
   colon3_node->name = c;
   return cons_head((node*)NODE_VARIABLE, (node*)colon3_node);
 }
@@ -946,11 +946,11 @@ new_and(parser_state *p, node *a, node *b)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_and_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_AND, class);
+  init_var_header(&n->header, p, NODE_AND, size_class);
   n->left = a;
   n->right = b;
 
@@ -964,11 +964,11 @@ new_or(parser_state *p, node *a, node *b)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_or_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_OR, class);
+  init_var_header(&n->header, p, NODE_OR, size_class);
   n->left = a;
   n->right = b;
 
@@ -992,12 +992,12 @@ new_array(parser_state *p, node *a)
   size_t elems_size = len * sizeof(struct mrb_ast_node*);
   size_t total_size = base_size + elems_size;
 
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
   struct mrb_ast_array_node *n = (struct mrb_ast_array_node*)
-    parser_alloc_var(p, total_size, class);
+    parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_ARRAY, class);
+  init_var_header(&n->header, p, NODE_ARRAY, size_class);
   n->len = len;
   n->flags = 0;
 
@@ -1018,9 +1018,9 @@ new_splat(parser_state *p, node *a)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_splat_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&splat_node->hdr, p, NODE_SPLAT, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&splat_node->hdr, p, NODE_SPLAT, size_class);
   splat_node->value = a;
   return cons_head((node*)NODE_VARIABLE, (node*)splat_node);
 }
@@ -1042,11 +1042,11 @@ new_hash(parser_state *p, node *a)
   size_t pairs_size = len * 2 * sizeof(struct mrb_ast_node*); /* key and value for each pair */
   size_t total_size = base_size + pairs_size;
 
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_HASH, class);
+  init_var_header(&n->header, p, NODE_HASH, size_class);
   n->len = len;
   n->flags = 0;
 
@@ -1074,9 +1074,9 @@ new_kw_hash(parser_state *p, node *a)
   }
 
   size_t total_size = sizeof(struct mrb_ast_kw_hash_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_kw_hash_node *kw_hash_node = (struct mrb_ast_kw_hash_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&kw_hash_node->hdr, p, NODE_KW_HASH, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_kw_hash_node *kw_hash_node = (struct mrb_ast_kw_hash_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&kw_hash_node->hdr, p, NODE_KW_HASH, size_class);
   kw_hash_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)kw_hash_node);
 }
@@ -1087,11 +1087,11 @@ static node*
 new_sym(parser_state *p, mrb_sym sym)
 {
   size_t size = sizeof(struct mrb_ast_sym_node);
-  enum mrb_ast_size_class class = size_to_class(size);
+  enum mrb_ast_size_class size_class = size_to_class(size);
 
-  struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_alloc_var(p, size, class);
+  struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, NODE_SYM, class);
+  init_var_header(&n->header, p, NODE_SYM, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1101,11 +1101,11 @@ static node*
 new_xvar(parser_state *p, mrb_sym sym, enum node_type type)
 {
   size_t size = sizeof(struct mrb_ast_var_node);
-  enum mrb_ast_size_class class = size_to_class(size);
+  enum mrb_ast_size_class size_class = size_to_class(size);
 
-  struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_alloc_var(p, size, class);
+  struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, type, class);
+  init_var_header(&n->header, p, type, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1150,9 +1150,9 @@ new_nvar(parser_state *p, int num)
   }
 
   size_t total_size = sizeof(struct mrb_ast_nvar_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_NVAR, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_NVAR, size_class);
   n->num = num;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1162,11 +1162,11 @@ static node*
 new_const(parser_state *p, mrb_sym sym)
 {
   size_t total_size = sizeof(struct mrb_ast_const_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_CONST, class);
+  init_var_header(&n->hdr, p, NODE_CONST, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1177,9 +1177,9 @@ static node*
 new_undef(parser_state *p, node *syms)
 {
   size_t total_size = sizeof(struct mrb_ast_undef_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&undef_node->hdr, p, NODE_UNDEF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&undef_node->hdr, p, NODE_UNDEF, size_class);
   undef_node->syms = syms;
   return cons_head((node*)NODE_VARIABLE, (node*)undef_node);
 }
@@ -1191,11 +1191,11 @@ new_class(parser_state *p, node *c, node *s, node *b)
   void_expr_error(p, s);
 
   size_t total_size = sizeof(struct mrb_ast_class_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_CLASS, class);
+  init_var_header(&n->header, p, NODE_CLASS, size_class);
   n->name = c;
   n->superclass = s;
   n->body = cons(locals_node(p), b);
@@ -1210,10 +1210,10 @@ new_sclass(parser_state *p, node *o, node *b)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_sclass_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_alloc_var(p, total_size, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_SCLASS, class);
+  init_var_header(&n->header, p, NODE_SCLASS, size_class);
   n->obj = o;
   n->body = cons(locals_node(p), b);
 
@@ -1225,11 +1225,11 @@ static node*
 new_module(parser_state *p, node *m, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_module_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MODULE, class);
+  init_var_header(&n->header, p, NODE_MODULE, size_class);
   n->name = m;
   n->body = cons(locals_node(p), b);
 
@@ -1241,11 +1241,11 @@ static node*
 new_def(parser_state *p, mrb_sym name)
 {
   size_t total_size = sizeof(struct mrb_ast_def_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_DEF, class);
+  init_var_header(&n->header, p, NODE_DEF, size_class);
   n->name = name;
   n->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
   n->locals = local_switch(p);
@@ -1274,9 +1274,9 @@ new_sdef(parser_state *p, node *o, mrb_sym name)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_sdef_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&sdef_node->header, p, NODE_SDEF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&sdef_node->header, p, NODE_SDEF, size_class);
   sdef_node->obj = o;
   sdef_node->name = name;
   sdef_node->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
@@ -1437,9 +1437,9 @@ static node*
 new_block_arg(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_block_arg_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&block_arg_node->hdr, p, NODE_BLOCK_ARG, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&block_arg_node->hdr, p, NODE_BLOCK_ARG, size_class);
   block_arg_node->value = a;
   return cons_head((node*)NODE_VARIABLE, (node*)block_arg_node);
 }
@@ -1483,11 +1483,11 @@ new_block(parser_state *p, node *a, node *b)
   a = setup_numparams(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_block_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_BLOCK, class);
+  init_var_header(&n->hdr, p, NODE_BLOCK, size_class);
   n->locals = locals_node(p);
   n->args = (struct mrb_ast_args *)a;
   n->body = b;
@@ -1502,9 +1502,9 @@ new_lambda(parser_state *p, node *a, node *b)
   a = setup_numparams(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_lambda_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&lambda_node->hdr, p, NODE_LAMBDA, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&lambda_node->hdr, p, NODE_LAMBDA, size_class);
   lambda_node->locals = locals_node(p);
   lambda_node->args = (struct mrb_ast_args *)a;
   lambda_node->body = b;
@@ -1518,11 +1518,11 @@ new_asgn(parser_state *p, node *a, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_asgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_ASGN, class);
+  init_var_header(&n->header, p, NODE_ASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1536,11 +1536,11 @@ new_masgn(parser_state *p, node *a, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_masgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MASGN, class);
+  init_var_header(&n->header, p, NODE_MASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1552,11 +1552,11 @@ static node*
 new_masgn_param(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_masgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MASGN, class);
+  init_var_header(&n->header, p, NODE_MASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1570,9 +1570,9 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_op_asgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_OP_ASGN, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_OP_ASGN, size_class);
   n->lhs = a;
   n->op = op;
   n->rhs = b;
@@ -1583,10 +1583,10 @@ static node*
 new_int_n(parser_state *p, int32_t val)
 {
   size_t size = sizeof(struct mrb_ast_int_node);
-  enum mrb_ast_size_class class = size_to_class(size);
-  struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_alloc_var(p, size, class);
+  enum mrb_ast_size_class size_class = size_to_class(size);
+  struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, NODE_INT, class);
+  init_var_header(&n->header, p, NODE_INT, size_class);
   n->value = val;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1693,10 +1693,10 @@ new_int(parser_state *p, const char *s, int base, int suffix)
   else {
     /* Big integer - create NODE_BIGINT */
     size_t size = sizeof(struct mrb_ast_bigint_node);
-    enum mrb_ast_size_class class = size_to_class(size);
-    struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_alloc_var(p, size, class);
+    enum mrb_ast_size_class size_class = size_to_class(size);
+    struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_alloc_var(p, size, size_class);
 
-    init_var_header(&n->header, p, NODE_BIGINT, class);
+    init_var_header(&n->header, p, NODE_BIGINT, size_class);
     n->string = strdup(s);
     n->base = base;
 
@@ -1720,11 +1720,11 @@ static node*
 new_float(parser_state *p, const char *s, int suffix)
 {
   size_t total_size = sizeof(struct mrb_ast_float_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_FLOAT, class);
+  init_var_header(&n->hdr, p, NODE_FLOAT, size_class);
   n->value = strdup(s);
 
   node* result = cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1745,11 +1745,11 @@ static node*
 new_str(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_str_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_STR, class);
+  init_var_header(&n->hdr, p, NODE_STR, size_class);
   n->list = a;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1760,9 +1760,9 @@ static node*
 new_xstr(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_xstr_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_XSTR, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_XSTR, size_class);
   n->list = a;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1772,9 +1772,9 @@ static node*
 new_dsym(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_dsym_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_dsym_node *n = (struct mrb_ast_dsym_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_DSYM, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_dsym_node *n = (struct mrb_ast_dsym_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_DSYM, size_class);
   n->list = a;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1784,9 +1784,9 @@ static node*
 new_dregx(parser_state *p, node *list, const char *flags, const char *encoding)
 {
   size_t total_size = sizeof(struct mrb_ast_dregx_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_dregx_node *n = (struct mrb_ast_dregx_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_DREGX, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_dregx_node *n = (struct mrb_ast_dregx_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_DREGX, size_class);
   n->list = list;
   n->flags = flags;
   n->encoding = encoding;
@@ -1798,9 +1798,9 @@ static node*
 new_back_ref(parser_state *p, int n)
 {
   size_t total_size = sizeof(struct mrb_ast_back_ref_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&backref_node->hdr, p, NODE_BACK_REF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&backref_node->hdr, p, NODE_BACK_REF, size_class);
   backref_node->type = n;
   return cons_head((node*)NODE_VARIABLE, (node*)backref_node);
 }
@@ -1810,9 +1810,9 @@ static node*
 new_nth_ref(parser_state *p, int n)
 {
   size_t total_size = sizeof(struct mrb_ast_nth_ref_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&nthref_node->hdr, p, NODE_NTH_REF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&nthref_node->hdr, p, NODE_NTH_REF, size_class);
   nthref_node->nth = n;
   return cons_head((node*)NODE_VARIABLE, (node*)nthref_node);
 }
@@ -1822,9 +1822,9 @@ static node*
 new_heredoc(parser_state *p, struct mrb_parser_heredoc_info **infop)
 {
   size_t total_size = sizeof(struct mrb_ast_heredoc_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_HEREDOC, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_HEREDOC, size_class);
 
   /* Initialize embedded heredoc info struct */
   n->info.allow_indent = FALSE;
@@ -1880,9 +1880,9 @@ static node*
 new_words(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_words_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&words_node->hdr, p, NODE_WORDS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&words_node->hdr, p, NODE_WORDS, size_class);
   words_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)words_node);
 }
@@ -1892,9 +1892,9 @@ static node*
 new_symbols(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_symbols_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&symbols_node->hdr, p, NODE_SYMBOLS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&symbols_node->hdr, p, NODE_SYMBOLS, size_class);
   symbols_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)symbols_node);
 }
@@ -2028,9 +2028,9 @@ static node*
 new_negate(parser_state *p, node *n)
 {
   size_t total_size = sizeof(struct mrb_ast_negate_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&negate_node->hdr, p, NODE_NEGATE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&negate_node->hdr, p, NODE_NEGATE, size_class);
   negate_node->operand = n;
   return cons_head((node*)NODE_VARIABLE, (node*)negate_node);
 }

mrbgems/mruby-compiler/core/y.tab.c

@@ -241,53 +241,53 @@ size_to_class(size_t size)
 
 /* Get maximum size for a size class */
 static inline size_t
-size_class_limit(enum mrb_ast_size_class class)
+size_class_limit(enum mrb_ast_size_class size_class)
 {
   static const size_t limits[] = SIZE_CLASS_LIMITS;
-  return (class < SIZE_CLASS_COUNT) ? limits[class] : 512;
+  return (size_class < SIZE_CLASS_COUNT) ? limits[size_class] : 512;
 }
 
 /* Allocate variable-sized node with size class management */
 static void*
-parser_alloc_var(parser_state *p, size_t size, enum mrb_ast_size_class class)
+parser_alloc_var(parser_state *p, size_t size, enum mrb_ast_size_class size_class)
 {
   /* Try to reuse from appropriate size class free list */
-  if (p->var_free_lists[class] && size <= size_class_limit(class)) {
-    struct mrb_ast_node *ptr = p->var_free_lists[class];
-    p->var_free_lists[class] = ptr->cdr;
-    p->var_alloc_counts[class]++;
+  if (p->var_free_lists[size_class] && size <= size_class_limit(size_class)) {
+    struct mrb_ast_node *ptr = p->var_free_lists[size_class];
+    p->var_free_lists[size_class] = ptr->cdr;
+    p->var_alloc_counts[size_class]++;
     return ptr;
   }
 
   /* Allocate new memory */
   void *ptr = parser_palloc(p, size);
   p->var_total_allocated += size;
-  p->var_alloc_counts[class]++;
+  p->var_alloc_counts[size_class]++;
   return ptr;
 }
 
 /* Free variable-sized node to appropriate size class list */
 /*
 static void
-parser_free_var(parser_state *p, void *ptr, enum mrb_ast_size_class class)
+parser_free_var(parser_state *p, void *ptr, enum mrb_ast_size_class size_class)
 {
   if (!ptr) return;
 
   struct mrb_ast_node *node = (struct mrb_ast_node*)ptr;
-  node->cdr = p->var_free_lists[class];
-  p->var_free_lists[class] = node;
+  node->cdr = p->var_free_lists[size_class];
+  p->var_free_lists[size_class] = node;
 }
 */
 
 /* Initialize variable node header */
 static void
 init_var_header(struct mrb_ast_var_header *header, parser_state *p,
-                enum node_type type, enum mrb_ast_size_class class)
+                enum node_type type, enum mrb_ast_size_class size_class)
 {
   header->lineno = p->lineno;
   header->filename_index = p->current_filename_index;
   header->node_type = (uint8_t)type;
-  header->size_class = (uint8_t)class;
+  header->size_class = (uint8_t)size_class;
   header->flags = 0;
 
   /* Handle file boundary edge case */
@@ -518,9 +518,9 @@ static node*
 new_scope(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_scope_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&scope_node->hdr, p, NODE_SCOPE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&scope_node->hdr, p, NODE_SCOPE, size_class);
   scope_node->locals = locals_node(p);
   scope_node->body = body;
   return cons_head((node*)NODE_VARIABLE, (node*)scope_node);
@@ -531,11 +531,11 @@ static node*
 new_stmts(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_stmts_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_STMTS, class);
+  init_var_header(&n->hdr, p, NODE_STMTS, size_class);
   n->stmts = body ? list1(body) : 0;  /* Wrap single statement in cons-list */
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -546,9 +546,9 @@ static node*
 new_begin(parser_state *p, node *body)
 {
   size_t total_size = sizeof(struct mrb_ast_begin_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&begin_node->hdr, p, NODE_BEGIN, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&begin_node->hdr, p, NODE_BEGIN, size_class);
   begin_node->body = body;
   return cons_head((node*)NODE_VARIABLE, (node*)begin_node);
 }
@@ -560,11 +560,11 @@ static node*
 new_rescue(parser_state *p, node *body, node *resq, node *els)
 {
   size_t total_size = sizeof(struct mrb_ast_rescue_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_RESCUE, class);
+  init_var_header(&n->hdr, p, NODE_RESCUE, size_class);
   n->body = body;
   n->rescue_clauses = resq;
   n->else_clause = els;
@@ -583,9 +583,9 @@ static node*
 new_ensure(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_ensure_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&ensure_node->hdr, p, NODE_ENSURE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&ensure_node->hdr, p, NODE_ENSURE, size_class);
   ensure_node->body = a;
   ensure_node->ensure_clause = b;
   return cons_head((node*)NODE_VARIABLE, (node*)ensure_node);
@@ -596,11 +596,11 @@ static node*
 new_nil(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_nil_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_NIL, class);
+  init_var_header(&n->hdr, p, NODE_NIL, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -610,11 +610,11 @@ static node*
 new_true(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_true_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_TRUE, class);
+  init_var_header(&n->hdr, p, NODE_TRUE, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -624,11 +624,11 @@ static node*
 new_false(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_false_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_FALSE, class);
+  init_var_header(&n->hdr, p, NODE_FALSE, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -638,9 +638,9 @@ static node*
 new_alias(parser_state *p, mrb_sym a, mrb_sym b)
 {
   size_t total_size = sizeof(struct mrb_ast_alias_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&alias_node->hdr, p, NODE_ALIAS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&alias_node->hdr, p, NODE_ALIAS, size_class);
   alias_node->new_name = a;
   alias_node->old_name = b;
   return cons_head((node*)NODE_VARIABLE, (node*)alias_node);
@@ -653,11 +653,11 @@ new_if(parser_state *p, node *condition, node *then_body, node *else_body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_if_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_if_node *n;
 
-  n = (struct mrb_ast_if_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_IF, class);
+  n = (struct mrb_ast_if_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_IF, size_class);
   n->condition = condition;
   n->then_body = then_body;
   n->else_body = else_body;
@@ -672,11 +672,11 @@ new_while(parser_state *p, node *condition, node *body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_while_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_while_node *n;
 
-  n = (struct mrb_ast_while_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_WHILE, class);
+  n = (struct mrb_ast_while_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_WHILE, size_class);
   n->condition = condition;
   n->body = body;
 
@@ -690,11 +690,11 @@ new_until(parser_state *p, node *condition, node *body)
   void_expr_error(p, condition);
 
   size_t total_size = sizeof(struct mrb_ast_until_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
   struct mrb_ast_until_node *n;
 
-  n = (struct mrb_ast_until_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_UNTIL, class);
+  n = (struct mrb_ast_until_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_UNTIL, size_class);
   n->condition = condition;
   n->body = body;
 
@@ -728,11 +728,11 @@ new_for(parser_state *p, node *v, node *o, node *b)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_for_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_FOR, class);
+  init_var_header(&n->header, p, NODE_FOR, size_class);
   n->var = v;
   n->iterable = o;
   n->body = b;
@@ -760,9 +760,9 @@ static node*
 new_postexe(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_postexe_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&postexe_node->hdr, p, NODE_POSTEXE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&postexe_node->hdr, p, NODE_POSTEXE, size_class);
   postexe_node->body = a;
   return cons_head((node*)NODE_VARIABLE, (node*)postexe_node);
 }
@@ -772,11 +772,11 @@ static node*
 new_self(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_self_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_SELF, class);
+  init_var_header(&n->hdr, p, NODE_SELF, size_class);
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -801,11 +801,11 @@ new_call(parser_state *p, node *receiver, mrb_sym method, node *args, int pass)
 
   /* Calculate size needed (fixed size now) */
   size_t total_size = sizeof(struct mrb_ast_call_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_CALL, class);
+  init_var_header(&n->header, p, NODE_CALL, size_class);
   n->receiver = receiver;
   n->method_name = method;
   n->argc = 0; /* argc will be determined at codegen time to handle splats */
@@ -840,11 +840,11 @@ static node*
 new_super(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_super_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_SUPER, class);
+  init_var_header(&n->header, p, NODE_SUPER, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -855,9 +855,9 @@ static node*
 new_zsuper(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_super_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_ZSUPER, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_ZSUPER, size_class);
   n->args = NULL;  /* zsuper initially has no args, but may be added by call_with_block */
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -871,11 +871,11 @@ new_yield(parser_state *p, node *c)
   }
 
   size_t total_size = sizeof(struct mrb_ast_yield_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_YIELD, class);
+  init_var_header(&n->header, p, NODE_YIELD, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -886,11 +886,11 @@ static node*
 new_return(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_return_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_RETURN, class);
+  init_var_header(&n->header, p, NODE_RETURN, size_class);
   n->args = c;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -901,9 +901,9 @@ static node*
 new_break(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_break_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_BREAK, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_BREAK, size_class);
   n->value = c;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -913,9 +913,9 @@ static node*
 new_next(parser_state *p, node *c)
 {
   size_t total_size = sizeof(struct mrb_ast_next_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_NEXT, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_NEXT, size_class);
   n->value = c;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -925,9 +925,9 @@ static node*
 new_redo(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_redo_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_REDO, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_REDO, size_class);
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
 
@@ -936,9 +936,9 @@ static node*
 new_retry(parser_state *p)
 {
   size_t total_size = sizeof(struct mrb_ast_retry_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_RETRY, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_RETRY, size_class);
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
 
@@ -947,11 +947,11 @@ static node*
 new_dot2(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_dot2_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_DOT2, class);
+  init_var_header(&n->hdr, p, NODE_DOT2, size_class);
   n->left = a;
   n->right = b;
 
@@ -963,11 +963,11 @@ static node*
 new_dot3(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_dot3_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_DOT3, class);
+  init_var_header(&n->hdr, p, NODE_DOT3, size_class);
   n->left = a;
   n->right = b;
 
@@ -981,9 +981,9 @@ new_colon2(parser_state *p, node *b, mrb_sym c)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_colon2_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&colon2_node->hdr, p, NODE_COLON2, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&colon2_node->hdr, p, NODE_COLON2, size_class);
   colon2_node->base = b;
   colon2_node->name = c;
   return cons_head((node*)NODE_VARIABLE, (node*)colon2_node);
@@ -994,9 +994,9 @@ static node*
 new_colon3(parser_state *p, mrb_sym c)
 {
   size_t total_size = sizeof(struct mrb_ast_colon3_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&colon3_node->hdr, p, NODE_COLON3, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&colon3_node->hdr, p, NODE_COLON3, size_class);
   colon3_node->name = c;
   return cons_head((node*)NODE_VARIABLE, (node*)colon3_node);
 }
@@ -1008,11 +1008,11 @@ new_and(parser_state *p, node *a, node *b)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_and_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_AND, class);
+  init_var_header(&n->header, p, NODE_AND, size_class);
   n->left = a;
   n->right = b;
 
@@ -1026,11 +1026,11 @@ new_or(parser_state *p, node *a, node *b)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_or_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_OR, class);
+  init_var_header(&n->header, p, NODE_OR, size_class);
   n->left = a;
   n->right = b;
 
@@ -1054,12 +1054,12 @@ new_array(parser_state *p, node *a)
   size_t elems_size = len * sizeof(struct mrb_ast_node*);
   size_t total_size = base_size + elems_size;
 
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
   struct mrb_ast_array_node *n = (struct mrb_ast_array_node*)
-    parser_alloc_var(p, total_size, class);
+    parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_ARRAY, class);
+  init_var_header(&n->header, p, NODE_ARRAY, size_class);
   n->len = len;
   n->flags = 0;
 
@@ -1080,9 +1080,9 @@ new_splat(parser_state *p, node *a)
   void_expr_error(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_splat_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&splat_node->hdr, p, NODE_SPLAT, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&splat_node->hdr, p, NODE_SPLAT, size_class);
   splat_node->value = a;
   return cons_head((node*)NODE_VARIABLE, (node*)splat_node);
 }
@@ -1104,11 +1104,11 @@ new_hash(parser_state *p, node *a)
   size_t pairs_size = len * 2 * sizeof(struct mrb_ast_node*); /* key and value for each pair */
   size_t total_size = base_size + pairs_size;
 
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_HASH, class);
+  init_var_header(&n->header, p, NODE_HASH, size_class);
   n->len = len;
   n->flags = 0;
 
@@ -1136,9 +1136,9 @@ new_kw_hash(parser_state *p, node *a)
   }
 
   size_t total_size = sizeof(struct mrb_ast_kw_hash_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_kw_hash_node *kw_hash_node = (struct mrb_ast_kw_hash_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&kw_hash_node->hdr, p, NODE_KW_HASH, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_kw_hash_node *kw_hash_node = (struct mrb_ast_kw_hash_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&kw_hash_node->hdr, p, NODE_KW_HASH, size_class);
   kw_hash_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)kw_hash_node);
 }
@@ -1149,11 +1149,11 @@ static node*
 new_sym(parser_state *p, mrb_sym sym)
 {
   size_t size = sizeof(struct mrb_ast_sym_node);
-  enum mrb_ast_size_class class = size_to_class(size);
+  enum mrb_ast_size_class size_class = size_to_class(size);
 
-  struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_alloc_var(p, size, class);
+  struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, NODE_SYM, class);
+  init_var_header(&n->header, p, NODE_SYM, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1163,11 +1163,11 @@ static node*
 new_xvar(parser_state *p, mrb_sym sym, enum node_type type)
 {
   size_t size = sizeof(struct mrb_ast_var_node);
-  enum mrb_ast_size_class class = size_to_class(size);
+  enum mrb_ast_size_class size_class = size_to_class(size);
 
-  struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_alloc_var(p, size, class);
+  struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, type, class);
+  init_var_header(&n->header, p, type, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1212,9 +1212,9 @@ new_nvar(parser_state *p, int num)
   }
 
   size_t total_size = sizeof(struct mrb_ast_nvar_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_NVAR, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_NVAR, size_class);
   n->num = num;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1224,11 +1224,11 @@ static node*
 new_const(parser_state *p, mrb_sym sym)
 {
   size_t total_size = sizeof(struct mrb_ast_const_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_CONST, class);
+  init_var_header(&n->hdr, p, NODE_CONST, size_class);
   n->symbol = sym;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1239,9 +1239,9 @@ static node*
 new_undef(parser_state *p, node *syms)
 {
   size_t total_size = sizeof(struct mrb_ast_undef_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&undef_node->hdr, p, NODE_UNDEF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&undef_node->hdr, p, NODE_UNDEF, size_class);
   undef_node->syms = syms;
   return cons_head((node*)NODE_VARIABLE, (node*)undef_node);
 }
@@ -1253,11 +1253,11 @@ new_class(parser_state *p, node *c, node *s, node *b)
   void_expr_error(p, s);
 
   size_t total_size = sizeof(struct mrb_ast_class_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_CLASS, class);
+  init_var_header(&n->header, p, NODE_CLASS, size_class);
   n->name = c;
   n->superclass = s;
   n->body = cons(locals_node(p), b);
@@ -1272,10 +1272,10 @@ new_sclass(parser_state *p, node *o, node *b)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_sclass_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_alloc_var(p, total_size, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_SCLASS, class);
+  init_var_header(&n->header, p, NODE_SCLASS, size_class);
   n->obj = o;
   n->body = cons(locals_node(p), b);
 
@@ -1287,11 +1287,11 @@ static node*
 new_module(parser_state *p, node *m, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_module_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MODULE, class);
+  init_var_header(&n->header, p, NODE_MODULE, size_class);
   n->name = m;
   n->body = cons(locals_node(p), b);
 
@@ -1303,11 +1303,11 @@ static node*
 new_def(parser_state *p, mrb_sym name)
 {
   size_t total_size = sizeof(struct mrb_ast_def_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_DEF, class);
+  init_var_header(&n->header, p, NODE_DEF, size_class);
   n->name = name;
   n->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
   n->locals = local_switch(p);
@@ -1336,9 +1336,9 @@ new_sdef(parser_state *p, node *o, mrb_sym name)
   void_expr_error(p, o);
 
   size_t total_size = sizeof(struct mrb_ast_sdef_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&sdef_node->header, p, NODE_SDEF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&sdef_node->header, p, NODE_SDEF, size_class);
   sdef_node->obj = o;
   sdef_node->name = name;
   sdef_node->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
@@ -1499,9 +1499,9 @@ static node*
 new_block_arg(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_block_arg_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&block_arg_node->hdr, p, NODE_BLOCK_ARG, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&block_arg_node->hdr, p, NODE_BLOCK_ARG, size_class);
   block_arg_node->value = a;
   return cons_head((node*)NODE_VARIABLE, (node*)block_arg_node);
 }
@@ -1545,11 +1545,11 @@ new_block(parser_state *p, node *a, node *b)
   a = setup_numparams(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_block_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_BLOCK, class);
+  init_var_header(&n->hdr, p, NODE_BLOCK, size_class);
   n->locals = locals_node(p);
   n->args = (struct mrb_ast_args *)a;
   n->body = b;
@@ -1564,9 +1564,9 @@ new_lambda(parser_state *p, node *a, node *b)
   a = setup_numparams(p, a);
 
   size_t total_size = sizeof(struct mrb_ast_lambda_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&lambda_node->hdr, p, NODE_LAMBDA, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&lambda_node->hdr, p, NODE_LAMBDA, size_class);
   lambda_node->locals = locals_node(p);
   lambda_node->args = (struct mrb_ast_args *)a;
   lambda_node->body = b;
@@ -1580,11 +1580,11 @@ new_asgn(parser_state *p, node *a, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_asgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_ASGN, class);
+  init_var_header(&n->header, p, NODE_ASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1598,11 +1598,11 @@ new_masgn(parser_state *p, node *a, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_masgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MASGN, class);
+  init_var_header(&n->header, p, NODE_MASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1614,11 +1614,11 @@ static node*
 new_masgn_param(parser_state *p, node *a, node *b)
 {
   size_t total_size = sizeof(struct mrb_ast_masgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->header, p, NODE_MASGN, class);
+  init_var_header(&n->header, p, NODE_MASGN, size_class);
   n->lhs = a;
   n->rhs = b;
 
@@ -1632,9 +1632,9 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
   void_expr_error(p, b);
 
   size_t total_size = sizeof(struct mrb_ast_op_asgn_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->header, p, NODE_OP_ASGN, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->header, p, NODE_OP_ASGN, size_class);
   n->lhs = a;
   n->op = op;
   n->rhs = b;
@@ -1645,10 +1645,10 @@ static node*
 new_int_n(parser_state *p, int32_t val)
 {
   size_t size = sizeof(struct mrb_ast_int_node);
-  enum mrb_ast_size_class class = size_to_class(size);
-  struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_alloc_var(p, size, class);
+  enum mrb_ast_size_class size_class = size_to_class(size);
+  struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_alloc_var(p, size, size_class);
 
-  init_var_header(&n->header, p, NODE_INT, class);
+  init_var_header(&n->header, p, NODE_INT, size_class);
   n->value = val;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1755,10 +1755,10 @@ new_int(parser_state *p, const char *s, int base, int suffix)
   else {
     /* Big integer - create NODE_BIGINT */
     size_t size = sizeof(struct mrb_ast_bigint_node);
-    enum mrb_ast_size_class class = size_to_class(size);
-    struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_alloc_var(p, size, class);
+    enum mrb_ast_size_class size_class = size_to_class(size);
+    struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_alloc_var(p, size, size_class);
 
-    init_var_header(&n->header, p, NODE_BIGINT, class);
+    init_var_header(&n->header, p, NODE_BIGINT, size_class);
     n->string = strdup(s);
     n->base = base;
 
@@ -1782,11 +1782,11 @@ static node*
 new_float(parser_state *p, const char *s, int suffix)
 {
   size_t total_size = sizeof(struct mrb_ast_float_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_FLOAT, class);
+  init_var_header(&n->hdr, p, NODE_FLOAT, size_class);
   n->value = strdup(s);
 
   node* result = cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1807,11 +1807,11 @@ static node*
 new_str(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_str_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
 
-  struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_alloc_var(p, total_size, class);
+  struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_alloc_var(p, total_size, size_class);
 
-  init_var_header(&n->hdr, p, NODE_STR, class);
+  init_var_header(&n->hdr, p, NODE_STR, size_class);
   n->list = a;
 
   return cons_head((node*)NODE_VARIABLE, (node*)n);
@@ -1822,9 +1822,9 @@ static node*
 new_xstr(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_xstr_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_XSTR, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_XSTR, size_class);
   n->list = a;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1834,9 +1834,9 @@ static node*
 new_dsym(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_dsym_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_dsym_node *n = (struct mrb_ast_dsym_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_DSYM, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_dsym_node *n = (struct mrb_ast_dsym_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_DSYM, size_class);
   n->list = a;
   return cons_head((node*)NODE_VARIABLE, (node*)n);
 }
@@ -1846,9 +1846,9 @@ static node*
 new_dregx(parser_state *p, node *list, const char *flags, const char *encoding)
 {
   size_t total_size = sizeof(struct mrb_ast_dregx_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_dregx_node *n = (struct mrb_ast_dregx_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_DREGX, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_dregx_node *n = (struct mrb_ast_dregx_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_DREGX, size_class);
   n->list = list;
   n->flags = flags;
   n->encoding = encoding;
@@ -1860,9 +1860,9 @@ static node*
 new_back_ref(parser_state *p, int n)
 {
   size_t total_size = sizeof(struct mrb_ast_back_ref_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&backref_node->hdr, p, NODE_BACK_REF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&backref_node->hdr, p, NODE_BACK_REF, size_class);
   backref_node->type = n;
   return cons_head((node*)NODE_VARIABLE, (node*)backref_node);
 }
@@ -1872,9 +1872,9 @@ static node*
 new_nth_ref(parser_state *p, int n)
 {
   size_t total_size = sizeof(struct mrb_ast_nth_ref_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&nthref_node->hdr, p, NODE_NTH_REF, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&nthref_node->hdr, p, NODE_NTH_REF, size_class);
   nthref_node->nth = n;
   return cons_head((node*)NODE_VARIABLE, (node*)nthref_node);
 }
@@ -1884,9 +1884,9 @@ static node*
 new_heredoc(parser_state *p, struct mrb_parser_heredoc_info **infop)
 {
   size_t total_size = sizeof(struct mrb_ast_heredoc_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&n->hdr, p, NODE_HEREDOC, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&n->hdr, p, NODE_HEREDOC, size_class);
 
   /* Initialize embedded heredoc info struct */
   n->info.allow_indent = FALSE;
@@ -1942,9 +1942,9 @@ static node*
 new_words(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_words_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&words_node->hdr, p, NODE_WORDS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&words_node->hdr, p, NODE_WORDS, size_class);
   words_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)words_node);
 }
@@ -1954,9 +1954,9 @@ static node*
 new_symbols(parser_state *p, node *a)
 {
   size_t total_size = sizeof(struct mrb_ast_symbols_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&symbols_node->hdr, p, NODE_SYMBOLS, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&symbols_node->hdr, p, NODE_SYMBOLS, size_class);
   symbols_node->args = a;
   return cons_head((node*)NODE_VARIABLE, (node*)symbols_node);
 }
@@ -2090,9 +2090,9 @@ static node*
 new_negate(parser_state *p, node *n)
 {
   size_t total_size = sizeof(struct mrb_ast_negate_node);
-  enum mrb_ast_size_class class = size_to_class(total_size);
-  struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_alloc_var(p, total_size, class);
-  init_var_header(&negate_node->hdr, p, NODE_NEGATE, class);
+  enum mrb_ast_size_class size_class = size_to_class(total_size);
+  struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_alloc_var(p, total_size, size_class);
+  init_var_header(&negate_node->hdr, p, NODE_NEGATE, size_class);
   negate_node->operand = n;
   return cons_head((node*)NODE_VARIABLE, (node*)negate_node);
 }