rbs 2.8.4 → 3.8.1

data/ext/rbs_extension/parser.c

@@ -37,6 +37,9 @@
   case kPUBLIC: \
   case kPRIVATE: \
   case kUNTYPED: \
+  case kUSE: \
+  case kAS: \
+  case k__TODO__: \
   /* nop */
 
 typedef struct {
@@ -49,6 +52,18 @@ typedef struct {
   VALUE rest_keywords;
 } method_params;
 
+static VALUE EMPTY_ARRAY;
+
+static inline void melt_array(VALUE *array) {
+  if (*array == EMPTY_ARRAY) {
+    *array = rb_ary_new();
+  }
+}
+
+static bool rbs_is_untyped_params(method_params *params) {
+  return NIL_P(params->required_positionals);
+}
+
 // /**
 //  * Returns RBS::Location object of `current_token` of a parser state.
 //  *
@@ -75,7 +90,7 @@ static VALUE string_of_loc(parserstate *state, position start, position end) {
 }
 
 /**
- * Raises RuntimeError with "Unexpected error " messsage.
+ * Raises RuntimeError with "Unexpected error " message.
  * */
 static NORETURN(void) rbs_abort(void) {
   rb_raise(
@@ -128,10 +143,9 @@ void parser_advance_no_gap(parserstate *state) {
               | {(tUIDENT `::`)*} <tXIDENT>
               | {<tXIDENT>}
 */
-VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
+static VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
   VALUE absolute = Qfalse;
-  VALUE path = rb_ary_new();
-  VALUE namespace;
+  VALUE path = EMPTY_ARRAY;
 
   if (rg) {
     rg->start = state->current_token.range.start;
@@ -148,12 +162,14 @@ VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
     && state->current_token.range.end.byte_pos == state->next_token.range.start.byte_pos
     && state->next_token.range.end.byte_pos == state->next_token2.range.start.byte_pos
   ) {
+    melt_array(&path);
     rb_ary_push(path, ID2SYM(INTERN_TOKEN(state, state->current_token)));
 
     parser_advance(state);
     parser_advance(state);
   }
-  namespace = rbs_namespace(path, absolute);
+
+  VALUE namespace = rbs_namespace(path, absolute);
 
   switch (state->current_token.type) {
     case tLIDENT:
@@ -204,9 +220,10 @@ VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
   type_list ::= {} type `,` ... <`,`> eol
               | {} type `,` ... `,` <type> eol
 */
-static VALUE parse_type_list(parserstate *state, enum TokenType eol, VALUE types) {
+static void parse_type_list(parserstate *state, enum TokenType eol, VALUE *types) {
   while (true) {
-    rb_ary_push(types, parse_type(state));
+    melt_array(types);
+    rb_ary_push(*types, parse_type(state));
 
     if (state->next_token.type == pCOMMA) {
       parser_advance(state);
@@ -226,8 +243,6 @@ static VALUE parse_type_list(parserstate *state, enum TokenType eol, VALUE types
       }
     }
   }
-
-  return types;
 }
 
 static bool is_keyword_token(enum TokenType type) {
@@ -252,7 +267,6 @@ static bool is_keyword_token(enum TokenType type) {
 */
 static VALUE parse_function_param(parserstate *state) {
   range type_range;
-
   type_range.start = state->next_token.range.start;
   VALUE type = parse_type(state);
   type_range.end = state->current_token.range.end;
@@ -262,20 +276,32 @@ static VALUE parse_function_param(parserstate *state) {
 
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
     rbs_loc_add_optional_child(loc, rb_intern("name"), NULL_RANGE);
 
     return rbs_function_param(type, Qnil, location);
   } else {
     range name_range = state->next_token.range;
-    range param_range;
 
     parser_advance(state);
-    param_range.start = type_range.start;
-    param_range.end = name_range.end;
+
+    range param_range = {
+      .start = type_range.start,
+      .end = name_range.end,
+    };
+
+    if (!is_keyword_token(state->current_token.type)) {
+      raise_syntax_error(
+        state,
+        state->current_token,
+        "unexpected token for function parameter name"
+      );
+    }
 
     VALUE name = rb_to_symbol(rbs_unquote_string(state, state->current_token.range, 0));
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
     rbs_loc_add_optional_child(loc, rb_intern("name"), name_range);
 
     return rbs_function_param(type, name, location);
@@ -295,30 +321,35 @@ static ID intern_token_start_end(parserstate *state, token start_token, token en
                 | {} keyword <`?`> `:`
 */
 static VALUE parse_keyword_key(parserstate *state) {
-  VALUE key;
-
   parser_advance(state);
 
   if (state->next_token.type == pQUESTION) {
-    key = ID2SYM(intern_token_start_end(state, state->current_token, state->next_token));
+    VALUE key = ID2SYM(intern_token_start_end(state, state->current_token, state->next_token));
     parser_advance(state);
+    return key;
   } else {
-    key = ID2SYM(INTERN_TOKEN(state, state->current_token));
+    return ID2SYM(INTERN_TOKEN(state, state->current_token));
   }
-
-  return key;
 }
 
 /*
   keyword ::= {} keyword `:` <function_param>
 */
-static void parse_keyword(parserstate *state, VALUE keywords) {
-  VALUE key;
-  VALUE param;
+static void parse_keyword(parserstate *state, VALUE keywords, VALUE memo) {
+  VALUE key = parse_keyword_key(state);
+
+  if (!NIL_P(rb_hash_aref(memo, key))) {
+    raise_syntax_error(
+      state,
+      state->current_token,
+      "duplicated keyword argument"
+    );
+  } else {
+    rb_hash_aset(memo, key, Qtrue);
+  }
 
-  key = parse_keyword_key(state);
   parser_advance_assert(state, pCOLON);
-  param = parse_function_param(state);
+  VALUE param = parse_function_param(state);
 
   rb_hash_aset(keywords, key, param);
 
@@ -349,6 +380,7 @@ static bool is_keyword(parserstate *state) {
 
 /*
   params ::= {} `)`
+           | {} `?` `)`               -- Untyped function params (assign params.required = nil)
            | <required_params> `)`
            | <required_params> `,` `)`
 
@@ -376,10 +408,17 @@ static bool is_keyword(parserstate *state) {
              | {} `**` <function_param>
 */
 static void parse_params(parserstate *state, method_params *params) {
+  if (state->next_token.type == pQUESTION && state->next_token2.type == pRPAREN) {
+    params->required_positionals = Qnil;
+    parser_advance(state);
+    return;
+  }
   if (state->next_token.type == pRPAREN) {
     return;
   }
 
+  VALUE memo = rb_hash_new();
+
   while (true) {
     VALUE param;
 
@@ -399,6 +438,7 @@ static void parse_params(parserstate *state, method_params *params) {
         }
 
         param = parse_function_param(state);
+        melt_array(&params->required_positionals);
         rb_ary_push(params->required_positionals, param);
 
         break;
@@ -418,12 +458,13 @@ PARSE_OPTIONAL_PARAMS:
         parser_advance(state);
 
         if (is_keyword(state)) {
-          parse_keyword(state, params->optional_keywords);
+          parse_keyword(state, params->optional_keywords, memo);
           parser_advance_if(state, pCOMMA);
           goto PARSE_KEYWORDS;
         }
 
         param = parse_function_param(state);
+        melt_array(&params->optional_positionals);
         rb_ary_push(params->optional_positionals, param);
 
         break;
@@ -467,6 +508,7 @@ PARSE_TRAILING_PARAMS:
         }
 
         param = parse_function_param(state);
+        melt_array(&params->trailing_positionals);
         rb_ary_push(params->trailing_positionals, param);
 
         break;
@@ -483,7 +525,7 @@ PARSE_KEYWORDS:
     case pQUESTION:
       parser_advance(state);
       if (is_keyword(state)) {
-        parse_keyword(state, params->optional_keywords);
+        parse_keyword(state, params->optional_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -500,12 +542,13 @@ PARSE_KEYWORDS:
 
     case tUIDENT:
     case tLIDENT:
+    case tQIDENT:
     case tULIDENT:
     case tULLIDENT:
     case tBANGIDENT:
     KEYWORD_CASES
       if (is_keyword(state)) {
-        parse_keyword(state, params->required_keywords);
+        parse_keyword(state, params->required_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -543,6 +586,7 @@ EOP:
 static VALUE parse_optional(parserstate *state) {
   range rg;
   rg.start = state->next_token.range.start;
+
   VALUE type = parse_simple(state);
 
   if (state->next_token.type == pQUESTION) {
@@ -556,13 +600,15 @@ static VALUE parse_optional(parserstate *state) {
 }
 
 static void initialize_method_params(method_params *params){
-  params->required_positionals = rb_ary_new();
-  params->optional_positionals = rb_ary_new();
-  params->rest_positionals = Qnil;
-  params->trailing_positionals = rb_ary_new();
-  params->required_keywords = rb_hash_new();
-  params->optional_keywords = rb_hash_new();
-  params->rest_keywords = Qnil;
+  *params = (method_params) {
+    .required_positionals = EMPTY_ARRAY,
+    .optional_positionals = EMPTY_ARRAY,
+    .rest_positionals = Qnil,
+    .trailing_positionals = EMPTY_ARRAY,
+    .required_keywords = rb_hash_new(),
+    .optional_keywords = rb_hash_new(),
+    .rest_keywords = Qnil,
+  };
 }
 
 /*
@@ -599,6 +645,13 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
     parser_advance_assert(state, pRPAREN);
   }
 
+  // Untyped method parameter means it cannot have block
+  if (rbs_is_untyped_params(&params)) {
+    if (state->next_token.type != pARROW) {
+      raise_syntax_error(state, state->next_token2, "A method type with untyped method parameter cannot have block");
+    }
+  }
+
   // Passing NULL to function_self_type means the function itself doesn't accept self type binding. (== method type)
   if (function_self_type) {
     *function_self_type = parse_self_type_binding(state);
@@ -627,8 +680,11 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
     parser_advance_assert(state, pARROW);
     VALUE block_return_type = parse_optional(state);
 
-    *block = rbs_block(
-      rbs_function(
+    VALUE block_function = Qnil;
+    if (rbs_is_untyped_params(&block_params)) {
+      block_function = rbs_untyped_function(block_return_type);
+    } else {
+      block_function = rbs_function(
         block_params.required_positionals,
         block_params.optional_positionals,
         block_params.rest_positionals,
@@ -637,10 +693,10 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
         block_params.optional_keywords,
         block_params.rest_keywords,
         block_return_type
-      ),
-      required,
-      block_self_type
-    );
+      );
+    }
+
+    *block = rbs_block(block_function, required, block_self_type);
 
     parser_advance_assert(state, pRBRACE);
   }
@@ -648,16 +704,20 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
   parser_advance_assert(state, pARROW);
   VALUE type = parse_optional(state);
 
-  *function = rbs_function(
-    params.required_positionals,
-    params.optional_positionals,
-    params.rest_positionals,
-    params.trailing_positionals,
-    params.required_keywords,
-    params.optional_keywords,
-    params.rest_keywords,
-    type
-  );
+  if (rbs_is_untyped_params(&params)) {
+    *function = rbs_untyped_function(type);
+  } else {
+    *function = rbs_function(
+      params.required_positionals,
+      params.optional_positionals,
+      params.rest_positionals,
+      params.trailing_positionals,
+      params.required_keywords,
+      params.optional_keywords,
+      params.rest_keywords,
+      type
+    );
+  }
 }
 
 /*
@@ -675,6 +735,16 @@ static VALUE parse_proc_type(parserstate *state) {
   return rbs_proc(function, block, loc, proc_self);
 }
 
+static void check_key_duplication(parserstate *state, VALUE fields, VALUE key) {
+  if (!NIL_P(rb_hash_aref(fields, key))) {
+    raise_syntax_error(
+      state,
+      state->current_token,
+      "duplicated record key"
+    );
+  }
+}
+
 /**
  * ... `{` ... `}` ...
  *        >   >
@@ -685,20 +755,28 @@ static VALUE parse_proc_type(parserstate *state) {
   record_attribute ::= {} keyword_token `:` <type>
                      | {} literal_type `=>` <type>
 */
-VALUE parse_record_attributes(parserstate *state) {
-  VALUE hash = rb_hash_new();
+static VALUE parse_record_attributes(parserstate *state) {
+  VALUE fields = rb_hash_new();
 
   if (state->next_token.type == pRBRACE) {
-    return hash;
+    return fields;
   }
 
   while (true) {
-    VALUE key;
-    VALUE type;
+    VALUE key, type,
+          value = rb_ary_new(),
+          required = Qtrue;
+
+    if (state->next_token.type == pQUESTION) {
+      // { ?foo: type } syntax
+      required = Qfalse;
+      parser_advance(state);
+    }
 
     if (is_keyword(state)) {
       // { foo: type } syntax
       key = parse_keyword_key(state);
+      check_key_duplication(state, fields, key);
       parser_advance_assert(state, pCOLON);
     } else {
       // { key => type } syntax
@@ -710,9 +788,10 @@ VALUE parse_record_attributes(parserstate *state) {
       case tDQSTRING:
       case tINTEGER:
       case kTRUE:
-      case kFALSE:
-        key = rb_funcall(parse_type(state), rb_intern("literal"), 0);
+      case kFALSE: {
+        key = rb_funcall(parse_simple(state), rb_intern("literal"), 0);
         break;
+      }
       default:
         raise_syntax_error(
           state,
@@ -720,10 +799,13 @@ VALUE parse_record_attributes(parserstate *state) {
           "unexpected record key token"
         );
       }
+      check_key_duplication(state, fields, key);
       parser_advance_assert(state, pFATARROW);
     }
     type = parse_type(state);
-    rb_hash_aset(hash, key, type);
+    rb_ary_push(value, type);
+    rb_ary_push(value, required);
+    rb_hash_aset(fields, key, value);
 
     if (parser_advance_if(state, pCOMMA)) {
       if (state->next_token.type == pRBRACE) {
@@ -733,8 +815,7 @@ VALUE parse_record_attributes(parserstate *state) {
       break;
     }
   }
-
-  return hash;
+  return fields;
 }
 
 /*
@@ -782,17 +863,14 @@ static VALUE parse_symbol(parserstate *state) {
              | {} `[` type_list <`]`>
  */
 static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
-    range name_range;
-    range args_range;
-    range type_range;
-
     TypeNameKind expected_kind = INTERFACE_NAME | CLASS_NAME;
     if (parse_alias) {
       expected_kind |= ALIAS_NAME;
     }
 
+    range name_range;
     VALUE typename = parse_type_name(state, expected_kind, &name_range);
-    VALUE types = rb_ary_new();
+    VALUE types = EMPTY_ARRAY;
 
     TypeNameKind kind;
     if (state->current_token.type == tUIDENT) {
@@ -805,21 +883,25 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
       rbs_abort();
     }
 
+    range args_range;
     if (state->next_token.type == pLBRACKET) {
       parser_advance(state);
       args_range.start = state->current_token.range.start;
-      parse_type_list(state, pRBRACKET, types);
+      parse_type_list(state, pRBRACKET, &types);
       parser_advance_assert(state, pRBRACKET);
       args_range.end = state->current_token.range.end;
     } else {
       args_range = NULL_RANGE;
     }
 
-    type_range.start = name_range.start;
-    type_range.end = nonnull_pos_or(args_range.end, name_range.end);
+    range type_range = {
+      .start = name_range.start,
+      .end = nonnull_pos_or(args_range.end, name_range.end),
+    };
 
     VALUE location = rbs_new_location(state->buffer, type_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
@@ -838,15 +920,14 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
   singleton_type ::= {`singleton`} `(` type_name <`)`>
 */
 static VALUE parse_singleton_type(parserstate *state) {
-  range name_range;
-  range type_range;
-
   parser_assert(state, kSINGLETON);
 
+  range type_range;
   type_range.start = state->current_token.range.start;
   parser_advance_assert(state, pLPAREN);
   parser_advance(state);
 
+  range name_range;
   VALUE typename = parse_type_name(state, CLASS_NAME, &name_range);
 
   parser_advance_assert(state, pRPAREN);
@@ -854,6 +935,7 @@ static VALUE parse_singleton_type(parserstate *state) {
 
   VALUE location = rbs_new_location(state->buffer, type_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 1);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
 
   return rbs_class_singleton(typename, location);
@@ -878,24 +960,38 @@ static VALUE parse_simple(parserstate *state) {
     parser_advance_assert(state, pRPAREN);
     return type;
   }
-  case kBOOL:
-    return rbs_base_type(RBS_Types_Bases_Bool, rbs_location_current_token(state));
-  case kBOT:
-    return rbs_base_type(RBS_Types_Bases_Bottom, rbs_location_current_token(state));
-  case kCLASS:
-    return rbs_base_type(RBS_Types_Bases_Class, rbs_location_current_token(state));
-  case kINSTANCE:
-    return rbs_base_type(RBS_Types_Bases_Instance, rbs_location_current_token(state));
-  case kNIL:
-    return rbs_base_type(RBS_Types_Bases_Nil, rbs_location_current_token(state));
-  case kSELF:
-    return rbs_base_type(RBS_Types_Bases_Self, rbs_location_current_token(state));
-  case kTOP:
-    return rbs_base_type(RBS_Types_Bases_Top, rbs_location_current_token(state));
-  case kVOID:
-    return rbs_base_type(RBS_Types_Bases_Void, rbs_location_current_token(state));
-  case kUNTYPED:
-    return rbs_base_type(RBS_Types_Bases_Any, rbs_location_current_token(state));
+  case kBOOL: {
+    return rbs_bases_bool(rbs_location_current_token(state));
+  }
+  case kBOT: {
+    return rbs_bases_bottom(rbs_location_current_token(state));
+  }
+  case kCLASS: {
+    return rbs_bases_class(rbs_location_current_token(state));
+  }
+  case kINSTANCE: {
+    return rbs_bases_instance(rbs_location_current_token(state));
+  }
+  case kNIL: {
+    return rbs_bases_nil(rbs_location_current_token(state));
+  }
+  case kSELF: {
+    return rbs_bases_self(rbs_location_current_token(state));
+  }
+  case kTOP: {
+    return rbs_bases_top(rbs_location_current_token(state));
+  }
+  case kVOID: {
+    return rbs_bases_void(rbs_location_current_token(state));
+  }
+  case kUNTYPED: {
+    return rbs_bases_any(rbs_location_current_token(state));
+  }
+  case k__TODO__: {
+    VALUE type = rbs_bases_any(rbs_location_current_token(state));
+    rb_funcall(type, rb_intern("todo!"), 0);
+    return type;
+  }
   case tINTEGER: {
     VALUE literal = rb_funcall(
       string_of_loc(state, state->current_token.range.start, state->current_token.range.end),
@@ -907,10 +1003,12 @@ static VALUE parse_simple(parserstate *state) {
       rbs_location_current_token(state)
     );
   }
-  case kTRUE:
+  case kTRUE: {
     return rbs_literal(Qtrue, rbs_location_current_token(state));
-  case kFALSE:
+  }
+  case kFALSE: {
     return rbs_literal(Qfalse, rbs_location_current_token(state));
+  }
   case tSQSTRING:
   case tDQSTRING: {
     VALUE literal = rbs_unquote_string(state, state->current_token.range, 0);
@@ -933,16 +1031,18 @@ static VALUE parse_simple(parserstate *state) {
   }
   case tULIDENT: // fallthrough
   case tLIDENT: // fallthrough
-  case pCOLON2:
+  case pCOLON2: {
     return parse_instance_type(state, true);
-  case kSINGLETON:
+  }
+  case kSINGLETON: {
     return parse_singleton_type(state);
+  }
   case pLBRACKET: {
     range rg;
     rg.start = state->current_token.range.start;
-    VALUE types = rb_ary_new();
+    VALUE types = EMPTY_ARRAY;
     if (state->next_token.type != pRBRACKET) {
-      parse_type_list(state, pRBRACKET, types);
+      parse_type_list(state, pRBRACKET, &types);
     }
     parser_advance_assert(state, pRBRACKET);
     rg.end = state->current_token.range.end;
@@ -950,7 +1050,7 @@ static VALUE parse_simple(parserstate *state) {
     return rbs_tuple(types, rbs_new_location(state->buffer, rg));
   }
   case pAREF_OPR: {
-    return rbs_tuple(rb_ary_new(), rbs_new_location(state->buffer, state->current_token.range));
+    return rbs_tuple(EMPTY_ARRAY, rbs_new_location(state->buffer, state->current_token.range));
   }
   case pLBRACE: {
     position start = state->current_token.range.start;
@@ -978,8 +1078,8 @@ static VALUE parse_simple(parserstate *state) {
 */
 static VALUE parse_intersection(parserstate *state) {
   range rg;
-
   rg.start = state->next_token.range.start;
+
   VALUE type = parse_optional(state);
   VALUE intersection_types = rb_ary_new();
 
@@ -1005,8 +1105,8 @@ static VALUE parse_intersection(parserstate *state) {
 */
 VALUE parse_type(parserstate *state) {
   range rg;
-
   rg.start = state->next_token.range.start;
+
   VALUE type = parse_intersection(state);
   VALUE union_types = rb_ary_new();
 
@@ -1030,13 +1130,14 @@ VALUE parse_type(parserstate *state) {
   type_params ::= {} `[` type_param `,` ... <`]`>
                 | {<>}
 
-  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT    (module_type_params == true)
+  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT upper_bound? default_type?   (module_type_params == true)
 
-  type_param ::= tUIDENT                            (module_type_params == false)
+  type_param ::= tUIDENT upper_bound? default_type?                           (module_type_params == false)
 */
+static VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
+  VALUE params = EMPTY_ARRAY;
 
-VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
-  VALUE params = rb_ary_new();
+  bool required_param_allowed = true;
 
   if (state->next_token.type == pLBRACKET) {
     parser_advance(state);
@@ -1044,19 +1145,16 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
     rg->start = state->current_token.range.start;
 
     while (true) {
-      VALUE name;
       bool unchecked = false;
       VALUE variance = ID2SYM(rb_intern("invariant"));
       VALUE upper_bound = Qnil;
+      VALUE default_type = Qnil;
 
-      range param_range = NULL_RANGE;
-      range name_range;
-      range variance_range = NULL_RANGE;
-      range unchecked_range = NULL_RANGE;
-      range upper_bound_range = NULL_RANGE;
-
+      range param_range;
       param_range.start = state->next_token.range.start;
 
+      range variance_range = NULL_RANGE;
+      range unchecked_range = NULL_RANGE;
       if (module_type_params) {
         if (state->next_token.type == kUNCHECKED) {
           unchecked = true;
@@ -1082,22 +1180,39 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
       }
 
       parser_advance_assert(state, tUIDENT);
-      name_range = state->current_token.range;
+      range name_range = state->current_token.range;
 
       ID id = INTERN_TOKEN(state, state->current_token);
-      name = ID2SYM(id);
+      VALUE name = ID2SYM(id);
 
       parser_insert_typevar(state, id);
 
+      range upper_bound_range = NULL_RANGE;
       if (state->next_token.type == pLT) {
         parser_advance(state);
+        upper_bound_range.start = state->current_token.range.start;
+        upper_bound = parse_type(state);
+        upper_bound_range.end = state->current_token.range.end;
+      }
 
-        if (state->next_token.type == kSINGLETON) {
+      range default_type_range = NULL_RANGE;
+      if (module_type_params) {
+        if (state->next_token.type == pEQ) {
           parser_advance(state);
-          upper_bound = parse_singleton_type(state);
+
+          default_type_range.start = state->current_token.range.start;
+          default_type = parse_type(state);
+          default_type_range.end = state->current_token.range.end;
+
+          required_param_allowed = false;
         } else {
-          parser_advance(state);
-          upper_bound = parse_instance_type(state, false);
+          if (!required_param_allowed) {
+            raise_syntax_error(
+              state,
+              state->current_token,
+              "required type parameter is not allowed after optional type parameter"
+            );
+          }
         }
       }
 
@@ -1105,12 +1220,20 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
 
       VALUE location = rbs_new_location(state->buffer, param_range);
       rbs_loc *loc = rbs_check_location(location);
+      rbs_loc_alloc_children(loc, 5);
       rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
       rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
       rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
       rbs_loc_add_optional_child(loc, rb_intern("upper_bound"), upper_bound_range);
+      rbs_loc_add_optional_child(loc, rb_intern("default"), default_type_range);
+
+      VALUE param = rbs_ast_type_param(name, variance, upper_bound, default_type, location);
+
+      if (unchecked) {
+        rb_funcall(param, rb_intern("unchecked!"), 0);
+      }
 
-      VALUE param = rbs_ast_type_param(name, variance, unchecked, upper_bound, location);
+      melt_array(&params);
       rb_ary_push(params, param);
 
       if (state->next_token.type == pCOMMA) {
@@ -1142,20 +1265,19 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
   method_type ::= {} type_params <function>
   */
 VALUE parse_method_type(parserstate *state) {
-  range rg;
-  range params_range = NULL_RANGE;
-  range type_range;
-
-  VALUE function = Qnil;
-  VALUE block = Qnil;
   parser_push_typevar_table(state, false);
 
+  range rg;
   rg.start = state->next_token.range.start;
 
+  range params_range = NULL_RANGE;
   VALUE type_params = parse_type_params(state, &params_range, false);
 
+  range type_range;
   type_range.start = state->next_token.range.start;
 
+  VALUE function = Qnil;
+  VALUE block = Qnil;
   parse_function(state, &function, &block, NULL);
 
   rg.end = state->current_token.range.end;
@@ -1165,6 +1287,7 @@ VALUE parse_method_type(parserstate *state) {
 
   VALUE location = rbs_new_location(state->buffer, rg);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("type"), type_range);
   rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
 
@@ -1179,31 +1302,23 @@ VALUE parse_method_type(parserstate *state) {
 /*
   global_decl ::= {tGIDENT} `:` <type>
 */
-VALUE parse_global_decl(parserstate *state) {
+static VALUE parse_global_decl(parserstate *state) {
   range decl_range;
-  range name_range, colon_range;
-
-  VALUE typename;
-  VALUE type;
-  VALUE location;
-  VALUE comment;
-
-  rbs_loc *loc;
-
   decl_range.start = state->current_token.range.start;
-  comment = get_comment(state, decl_range.start.line);
 
-  name_range = state->current_token.range;
-  typename = ID2SYM(INTERN_TOKEN(state, state->current_token));
+  VALUE comment = get_comment(state, decl_range.start.line);
+  range name_range = state->current_token.range;
+  VALUE typename = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
   parser_advance_assert(state, pCOLON);
-  colon_range = state->current_token.range;
+  range colon_range = state->current_token.range;
 
-  type = parse_type(state);
+  VALUE type = parse_type(state);
   decl_range.end = state->current_token.range.end;
 
-  location = rbs_new_location(state->buffer, decl_range);
-  loc = rbs_check_location(location);
+  VALUE location = rbs_new_location(state->buffer, decl_range);
+  rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
 
@@ -1213,30 +1328,24 @@ VALUE parse_global_decl(parserstate *state) {
 /*
   const_decl ::= {const_name} `:` <type>
 */
-VALUE parse_const_decl(parserstate *state) {
+static VALUE parse_const_decl(parserstate *state) {
   range decl_range;
-  range name_range, colon_range;
-
-  VALUE typename;
-  VALUE type;
-  VALUE location;
-  VALUE comment;
-
-  rbs_loc *loc;
 
   decl_range.start = state->current_token.range.start;
-  comment = get_comment(state, decl_range.start.line);
+  VALUE comment = get_comment(state, decl_range.start.line);
 
-  typename = parse_type_name(state, CLASS_NAME, &name_range);
+  range name_range;
+  VALUE typename = parse_type_name(state, CLASS_NAME, &name_range);
 
   parser_advance_assert(state, pCOLON);
-  colon_range = state->current_token.range;
+  range colon_range = state->current_token.range;
 
-  type = parse_type(state);
+  VALUE type = parse_type(state);
   decl_range.end = state->current_token.range.end;
 
-  location = rbs_new_location(state->buffer, decl_range);
-  loc = rbs_check_location(location);
+  VALUE location = rbs_new_location(state->buffer, decl_range);
+  rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
 
@@ -1246,30 +1355,32 @@ VALUE parse_const_decl(parserstate *state) {
 /*
   type_decl ::= {kTYPE} alias_name `=` <type>
 */
-VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotations) {
-  range decl_range;
-  range keyword_range, name_range, params_range, eq_range;
-
+static VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotations) {
   parser_push_typevar_table(state, true);
 
+  range decl_range;
   decl_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, decl_range.start);
 
-  keyword_range = state->current_token.range;
+  range keyword_range = state->current_token.range;
 
   parser_advance(state);
+
+  range name_range;
   VALUE typename = parse_type_name(state, ALIAS_NAME, &name_range);
 
+  range params_range;
   VALUE type_params = parse_type_params(state, &params_range, true);
 
   parser_advance_assert(state, pEQ);
-  eq_range = state->current_token.range;
+  range eq_range = state->current_token.range;
 
   VALUE type = parse_type(state);
   decl_range.end = state->current_token.range.end;
 
   VALUE location = rbs_new_location(state->buffer, decl_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 4);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
@@ -1277,7 +1388,7 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
 
   parser_pop_typevar_table(state);
 
-  return rbs_ast_decl_alias(
+  return rbs_ast_decl_type_alias(
     typename,
     type_params,
     type,
@@ -1290,7 +1401,7 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
 /*
   annotation ::= {<tANNOTATION>}
 */
-VALUE parse_annotation(parserstate *state) {
+static VALUE parse_annotation(parserstate *state) {
   VALUE content = rb_funcall(state->buffer, rb_intern("content"), 0);
   rb_encoding *enc = rb_enc_get(content);
 
@@ -1346,7 +1457,7 @@ VALUE parse_annotation(parserstate *state) {
   annotations ::= {} annotation ... <annotation>
                 | {<>}
 */
-void parse_annotations(parserstate *state, VALUE annotations, position *annot_pos) {
+static void parse_annotations(parserstate *state, VALUE *annotations, position *annot_pos) {
   *annot_pos = NullPosition;
 
   while (true) {
@@ -1357,7 +1468,8 @@ void parse_annotations(parserstate *state, VALUE annotations, position *annot_po
         *annot_pos = state->current_token.range.start;
       }
 
-      rb_ary_push(annotations, parse_annotation(state));
+      melt_array(annotations);
+      rb_ary_push(*annotations, parse_annotation(state));
     } else {
       break;
     }
@@ -1368,7 +1480,7 @@ void parse_annotations(parserstate *state, VALUE annotations, position *annot_po
   method_name ::= {} <IDENT | keyword>
                 | {} (IDENT | keyword)~<`?`>
 */
-VALUE parse_method_name(parserstate *state, range *range) {
+static VALUE parse_method_name(parserstate *state, range *range) {
   parser_advance(state);
 
   switch (state->current_token.type)
@@ -1400,8 +1512,9 @@ VALUE parse_method_name(parserstate *state, range *range) {
     *range = state->current_token.range;
     return ID2SYM(INTERN_TOKEN(state, state->current_token));
 
-  case tQIDENT:
+  case tQIDENT: {
     return rb_to_symbol(rbs_unquote_string(state, state->current_token.range, 0));
+  }
 
   case pBAR:
   case pHAT:
@@ -1436,7 +1549,7 @@ typedef enum {
 
   @param allow_selfq `true` to accept `self?` kind.
 */
-InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool allow_selfq, range *rg) {
+static InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool allow_selfq, range *rg) {
   InstanceSingletonKind kind = INSTANCE_KIND;
 
   if (state->next_token.type == kSELF) {
@@ -1446,8 +1559,6 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
       parser_advance(state);
       parser_advance(state);
       kind = SINGLETON_KIND;
-      rg->start = self_range.start;
-      rg->end = state->current_token.range.end;
     } else if (
       state->next_token2.type == pQUESTION
     && state->next_token.range.end.char_pos == state->next_token2.range.start.char_pos
@@ -1457,9 +1568,12 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
       parser_advance(state);
       parser_advance(state);
       kind = INSTANCE_SINGLETON_KIND;
-      rg->start = self_range.start;
-      rg->end = state->current_token.range.end;
     }
+
+    *rg = (range) {
+      .start = self_range.start,
+      .end = state->current_token.range.end,
+    };
   } else {
     *rg = NULL_RANGE;
   }
@@ -1469,8 +1583,8 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
 
 /**
  * def_member ::= {kDEF} method_name `:` <method_types>
- *              | {kPRIVATE2} kDEF method_name `:` <method_types>
- *              | {kPUBLIC2} kDEF method_name `:` <method_types>
+ *              | {kPRIVATE} kDEF method_name `:` <method_types>
+ *              | {kPUBLIC} kDEF method_name `:` <method_types>
  *
  * method_types ::= {} <method_type>
  *                | {} <`...`>
@@ -1479,42 +1593,40 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
  * @param instance_only `true` to reject singleton method definition.
  * @param accept_overload `true` to accept overloading (...) definition.
  * */
-VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overload, position comment_pos, VALUE annotations) {
+static VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overload, position comment_pos, VALUE annotations) {
   range member_range;
-  range visibility_range;
-  range keyword_range;
-  range name_range;
-  range kind_range;
-  range overload_range = NULL_RANGE;
-
-  VALUE visibility;
-
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
+
   VALUE comment = get_comment(state, comment_pos.line);
 
+  range visibility_range;
+  VALUE visibility;
   switch (state->current_token.type)
   {
-  case kPRIVATE:
+  case kPRIVATE: {
     visibility_range = state->current_token.range;
     visibility = ID2SYM(rb_intern("private"));
     member_range.start = visibility_range.start;
     parser_advance(state);
     break;
-  case kPUBLIC:
+  }
+  case kPUBLIC: {
     visibility_range = state->current_token.range;
     visibility = ID2SYM(rb_intern("public"));
     member_range.start = visibility_range.start;
     parser_advance(state);
     break;
+  }
   default:
     visibility_range = NULL_RANGE;
     visibility = Qnil;
     break;
   }
 
-  keyword_range = state->current_token.range;
+  range keyword_range = state->current_token.range;
 
+  range kind_range;
   InstanceSingletonKind kind;
   if (instance_only) {
     kind_range = NULL_RANGE;
@@ -1523,9 +1635,10 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
     kind = parse_instance_singleton_kind(state, NIL_P(visibility), &kind_range);
   }
 
+  range name_range;
   VALUE name = parse_method_name(state, &name_range);
-  VALUE method_types = rb_ary_new();
-  VALUE overload = Qfalse;
+  VALUE overloads = rb_ary_new();
+  VALUE overloading = Qfalse;
 
   if (state->next_token.type == pDOT && RB_SYM2ID(name) == rb_intern("self?")) {
     raise_syntax_error(
@@ -1539,25 +1652,36 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
 
   parser_push_typevar_table(state, kind != INSTANCE_KIND);
 
+  range overloading_range = NULL_RANGE;
   bool loop = true;
   while (loop) {
+    VALUE annotations = EMPTY_ARRAY;
+    position overload_annot_pos = NullPosition;
+
+    if (state->next_token.type == tANNOTATION) {
+      parse_annotations(state, &annotations, &overload_annot_pos);
+    }
+
     switch (state->next_token.type) {
     case pLPAREN:
     case pARROW:
     case pLBRACE:
     case pLBRACKET:
     case pQUESTION:
-      rb_ary_push(method_types, parse_method_type(state));
-      member_range.end = state->current_token.range.end;
-      break;
+      {
+        VALUE method_type = parse_method_type(state);
+        rb_ary_push(overloads, rbs_ast_members_method_definition_overload(annotations, method_type));
+        member_range.end = state->current_token.range.end;
+        break;
+      }
 
     case pDOT3:
       if (accept_overload) {
-        overload = Qtrue;
+        overloading = Qtrue;
         parser_advance(state);
         loop = false;
-        overload_range = state->current_token.range;
-        member_range.end = overload_range.end;
+        overloading_range = state->current_token.range;
+        member_range.end = overloading_range.end;
         break;
       } else {
         raise_syntax_error(
@@ -1601,20 +1725,21 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
-  rbs_loc_add_optional_child(loc, rb_intern("overload"), overload_range);
+  rbs_loc_add_optional_child(loc, rb_intern("overloading"), overloading_range);
   rbs_loc_add_optional_child(loc, rb_intern("visibility"), visibility_range);
 
   return rbs_ast_members_method_definition(
     name,
     k,
-    method_types,
+    overloads,
     annotations,
     location,
     comment,
-    overload,
+    overloading,
     visibility
   );
 }
@@ -1625,7 +1750,7 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
  *
  * @param kind
  * */
-void class_instance_name(parserstate *state, TypeNameKind kind, VALUE *name, VALUE args, range *name_range, range *args_range) {
+void class_instance_name(parserstate *state, TypeNameKind kind, VALUE *name, VALUE *args, range *name_range, range *args_range) {
   parser_advance(state);
 
   *name = parse_type_name(state, kind, name_range);
@@ -1648,31 +1773,24 @@ void class_instance_name(parserstate *state, TypeNameKind kind, VALUE *name, VAL
  *
  * @param from_interface `true` when the member is in an interface.
  * */
-VALUE parse_mixin_member(parserstate *state, bool from_interface, position comment_pos, VALUE annotations) {
+static VALUE parse_mixin_member(parserstate *state, bool from_interface, position comment_pos, VALUE annotations) {
   range member_range;
-  range name_range;
-  range keyword_range;
-  range args_range = NULL_RANGE;
-  bool reset_typevar_scope;
-
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
 
-  keyword_range = state->current_token.range;
+  enum TokenType type = state->current_token.type;
+  range keyword_range = state->current_token.range;
 
-  VALUE klass = Qnil;
-  switch (state->current_token.type)
+  bool reset_typevar_scope;
+  switch (type)
   {
   case kINCLUDE:
-    klass = RBS_AST_Members_Include;
     reset_typevar_scope = false;
     break;
   case kEXTEND:
-    klass = RBS_AST_Members_Extend;
     reset_typevar_scope = true;
     break;
   case kPREPEND:
-    klass = RBS_AST_Members_Prepend;
     reset_typevar_scope = false;
     break;
   default:
@@ -1692,11 +1810,13 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
   parser_push_typevar_table(state, reset_typevar_scope);
 
   VALUE name;
-  VALUE args = rb_ary_new();
+  VALUE args = EMPTY_ARRAY;
+  range name_range;
+  range args_range = NULL_RANGE;
   class_instance_name(
     state,
     from_interface ? INTERFACE_NAME : (INTERFACE_NAME | CLASS_NAME),
-    &name, args, &name_range, &args_range
+    &name, &args, &name_range, &args_range
   );
 
   parser_pop_typevar_table(state);
@@ -1705,18 +1825,23 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 3);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
-  return rbs_ast_members_mixin(
-    klass,
-    name,
-    args,
-    annotations,
-    location,
-    get_comment(state, comment_pos.line)
-  );
+  VALUE comment = get_comment(state, comment_pos.line);
+  switch (type)
+  {
+  case kINCLUDE:
+    return rbs_ast_members_include(name, args, annotations, location, comment);
+  case kEXTEND:
+    return rbs_ast_members_extend(name, args, annotations, location, comment);
+  case kPREPEND:
+    return rbs_ast_members_prepend(name, args, annotations, location, comment);
+  default:
+    rbs_abort();
+  }
 }
 
 /**
@@ -1727,21 +1852,16 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
  *
  * @param[in] instance_only `true` to reject `self.` alias.
  * */
-VALUE parse_alias_member(parserstate *state, bool instance_only, position comment_pos, VALUE annotations) {
+static VALUE parse_alias_member(parserstate *state, bool instance_only, position comment_pos, VALUE annotations) {
   range member_range;
-  range keyword_range, new_name_range, old_name_range;
-  range new_kind_range, old_kind_range;
-
   member_range.start = state->current_token.range.start;
-  keyword_range = state->current_token.range;
+  range keyword_range = state->current_token.range;
 
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
   VALUE comment = get_comment(state, comment_pos.line);
 
-  VALUE new_name;
-  VALUE old_name;
-  VALUE kind;
-
+  VALUE kind, new_name, old_name;
+  range new_kind_range, old_kind_range, new_name_range, old_name_range;
   if (!instance_only && state->next_token.type == kSELF) {
     kind = ID2SYM(rb_intern("singleton"));
 
@@ -1768,6 +1888,7 @@ VALUE parse_alias_member(parserstate *state, bool instance_only, position commen
   member_range.end = state->current_token.range.end;
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("new_name"), new_name_range);
   rbs_loc_add_required_child(loc, rb_intern("old_name"), old_name_range);
@@ -1789,11 +1910,7 @@ VALUE parse_alias_member(parserstate *state, bool instance_only, position commen
                     | {kSELF} `.` tAIDENT `:` <type>
                     | {tA2IDENT} `:` <type>
 */
-VALUE parse_variable_member(parserstate *state, position comment_pos, VALUE annotations) {
-  range member_range;
-  range name_range, colon_range;
-  range kind_range = NULL_RANGE;
-
+static VALUE parse_variable_member(parserstate *state, position comment_pos, VALUE annotations) {
   if (rb_array_len(annotations) > 0) {
     raise_syntax_error(
       state,
@@ -1802,87 +1919,92 @@ VALUE parse_variable_member(parserstate *state, position comment_pos, VALUE anno
     );
   }
 
+  range member_range;
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
   VALUE comment = get_comment(state, comment_pos.line);
 
-  VALUE klass;
-  VALUE location;
-  VALUE name;
-  VALUE type;
-
   switch (state->current_token.type)
   {
-  case tAIDENT:
-    klass = RBS_AST_Members_InstanceVariable;
-
-    name_range = state->current_token.range;
-    name = ID2SYM(INTERN_TOKEN(state, state->current_token));
+  case tAIDENT: {
+    range name_range = state->current_token.range;
+    VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
     parser_advance_assert(state, pCOLON);
-    colon_range = state->current_token.range;
+    range colon_range = state->current_token.range;
 
-    type = parse_type(state);
+    VALUE type = parse_type(state);
     member_range.end = state->current_token.range.end;
 
-    break;
-
-  case tA2IDENT:
-    klass = RBS_AST_Members_ClassVariable;
+    VALUE location = rbs_new_location(state->buffer, member_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 3);
+    rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+    rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, rb_intern("kind"), NULL_RANGE);
 
-    name_range = state->current_token.range;
-    name = ID2SYM(INTERN_TOKEN(state, state->current_token));
+    return rbs_ast_members_instance_variable(name, type, location, comment);
+  }
+  case tA2IDENT: {
+    range name_range = state->current_token.range;
+    VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
     parser_advance_assert(state, pCOLON);
-    colon_range = state->current_token.range;
+    range colon_range = state->current_token.range;
 
     parser_push_typevar_table(state, true);
-    type = parse_type(state);
+    VALUE type = parse_type(state);
     parser_pop_typevar_table(state);
     member_range.end = state->current_token.range.end;
 
-    break;
-
-  case kSELF:
-    klass = RBS_AST_Members_ClassInstanceVariable;
+    VALUE location = rbs_new_location(state->buffer, member_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 3);
+    rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+    rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, rb_intern("kind"), NULL_RANGE);
 
-    kind_range.start = state->current_token.range.start;
-    kind_range.end = state->next_token.range.end;
+    return rbs_ast_members_class_variable(name, type, location, comment);
+  }
+  case kSELF: {
+    range kind_range = {
+      .start = state->current_token.range.start,
+      .end = state->next_token.range.end
+    };
 
     parser_advance_assert(state, pDOT);
     parser_advance_assert(state, tAIDENT);
 
-    name_range = state->current_token.range;
-    name = ID2SYM(INTERN_TOKEN(state, state->current_token));
+    range name_range = state->current_token.range;
+    VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
     parser_advance_assert(state, pCOLON);
-    colon_range = state->current_token.range;
+    range colon_range = state->current_token.range;
 
     parser_push_typevar_table(state, true);
-    type = parse_type(state);
+    VALUE type = parse_type(state);
     parser_pop_typevar_table(state);
     member_range.end = state->current_token.range.end;
 
-    break;
+    VALUE location = rbs_new_location(state->buffer, member_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 3);
+    rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
+    rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
 
+    return rbs_ast_members_class_instance_variable(name, type, location, comment);
+  }
   default:
     rbs_abort();
   }
-
-  location = rbs_new_location(state->buffer, member_range);
-  rbs_loc *loc = rbs_check_location(location);
-  rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
-  rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
-  rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
-
-  return rbs_ast_members_variable(klass, name, type, location, comment);
 }
 
 /*
   visibility_member ::= {<`public`>}
                       | {<`private`>}
 */
-VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
+static VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
   if (rb_array_len(annotations) > 0) {
     raise_syntax_error(
       state,
@@ -1891,24 +2013,17 @@ VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
     );
   }
 
-  VALUE klass;
+  VALUE location = rbs_new_location(state->buffer, state->current_token.range);
 
   switch (state->current_token.type)
   {
   case kPUBLIC:
-    klass = RBS_AST_Members_Public;
-    break;
+    return rbs_ast_members_public(location);
   case kPRIVATE:
-    klass = RBS_AST_Members_Private;
-    break;
+    return rbs_ast_members_private(location);
   default:
     rbs_abort();
   }
-
-  return rbs_ast_members_visibility(
-    klass,
-    rbs_new_location(state->buffer, state->current_token.range)
-  );
 }
 
 /*
@@ -1925,26 +2040,14 @@ VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
              | `(` tAIDENT `)`    # Ivar name
              | `(` `)`            # No variable
 */
-VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE annotations) {
+static VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE annotations) {
   range member_range;
-  range keyword_range, name_range, colon_range;
-  range kind_range = NULL_RANGE, ivar_range = NULL_RANGE, ivar_name_range = NULL_RANGE, visibility_range = NULL_RANGE;
-
-  InstanceSingletonKind is_kind;
-  VALUE klass;
-  VALUE kind;
-  VALUE attr_name;
-  VALUE ivar_name;
-  VALUE type;
-  VALUE comment;
-  VALUE location;
-  VALUE visibility;
-  rbs_loc *loc;
-
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
-  comment = get_comment(state, comment_pos.line);
+  VALUE comment = get_comment(state, comment_pos.line);
 
+  VALUE visibility;
+  range visibility_range;
   switch (state->current_token.type)
   {
   case kPRIVATE:
@@ -1963,31 +2066,18 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
     break;
   }
 
-  keyword_range = state->current_token.range;
-  switch (state->current_token.type)
-  {
-  case kATTRREADER:
-    klass = RBS_AST_Members_AttrReader;
-    break;
-  case kATTRWRITER:
-    klass = RBS_AST_Members_AttrWriter;
-    break;
-  case kATTRACCESSOR:
-    klass = RBS_AST_Members_AttrAccessor;
-    break;
-  default:
-    rbs_abort();
-  }
+  enum TokenType attr_type = state->current_token.type;
+  range keyword_range = state->current_token.range;
 
-  is_kind = parse_instance_singleton_kind(state, false, &kind_range);
-  if (is_kind == INSTANCE_KIND) {
-    kind = ID2SYM(rb_intern("instance"));
-  } else {
-    kind = ID2SYM(rb_intern("singleton"));
-  }
+  range kind_range;
+  InstanceSingletonKind is_kind = parse_instance_singleton_kind(state, false, &kind_range);
+  VALUE kind = ID2SYM(rb_intern((is_kind == INSTANCE_KIND) ? "instance" : "singleton"));
 
-  attr_name = parse_method_name(state, &name_range);
+  range name_range;
+  VALUE attr_name = parse_method_name(state, &name_range);
 
+  VALUE ivar_name;
+  range ivar_range, ivar_name_range;
   if (state->next_token.type == pLPAREN) {
     parser_advance_assert(state, pLPAREN);
     ivar_range.start = state->current_token.range.start;
@@ -1997,24 +2087,28 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
       ivar_name_range = state->current_token.range;
     } else {
       ivar_name = Qfalse;
+      ivar_name_range = NULL_RANGE;
     }
 
     parser_advance_assert(state, pRPAREN);
     ivar_range.end = state->current_token.range.end;
   } else {
+    ivar_range = NULL_RANGE;
     ivar_name = Qnil;
+    ivar_name_range = NULL_RANGE;
   }
 
   parser_advance_assert(state, pCOLON);
-  colon_range = state->current_token.range;
+  range colon_range = state->current_token.range;
 
   parser_push_typevar_table(state, is_kind == SINGLETON_KIND);
-  type = parse_type(state);
+  VALUE type = parse_type(state);
   parser_pop_typevar_table(state);
   member_range.end = state->current_token.range.end;
 
-  location = rbs_new_location(state->buffer, member_range);
-  loc = rbs_check_location(location);
+  VALUE location = rbs_new_location(state->buffer, member_range);
+  rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 7);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
@@ -2023,17 +2117,17 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
   rbs_loc_add_optional_child(loc, rb_intern("ivar_name"), ivar_name_range);
   rbs_loc_add_optional_child(loc, rb_intern("visibility"), visibility_range);
 
-  return rbs_ast_members_attribute(
-    klass,
-    attr_name,
-    type,
-    ivar_name,
-    kind,
-    annotations,
-    location,
-    comment,
-    visibility
-  );
+  switch (attr_type)
+  {
+  case kATTRREADER:
+    return rbs_ast_members_attr_reader(attr_name, type, ivar_name, kind, annotations, location, comment, visibility);
+  case kATTRWRITER:
+    return rbs_ast_members_attr_writer(attr_name, type, ivar_name, kind, annotations, location, comment, visibility);
+  case kATTRACCESSOR:
+    return rbs_ast_members_attr_accessor(attr_name, type, ivar_name, kind, annotations, location, comment, visibility);
+  default:
+    rbs_abort();
+  }
 }
 
 /*
@@ -2043,32 +2137,35 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
                      | mixin_member   (interface only)
                      | alias_member   (instance only)
 */
-VALUE parse_interface_members(parserstate *state) {
-  VALUE members = rb_ary_new();
+static VALUE parse_interface_members(parserstate *state) {
+  VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
-    VALUE annotations = rb_ary_new();
+    VALUE annotations = EMPTY_ARRAY;
     position annot_pos = NullPosition;
 
-    parse_annotations(state, annotations, &annot_pos);
+    parse_annotations(state, &annotations, &annot_pos);
 
     parser_advance(state);
 
     VALUE member;
     switch (state->current_token.type) {
-    case kDEF:
+    case kDEF: {
       member = parse_member_def(state, true, true, annot_pos, annotations);
       break;
+    }
 
     case kINCLUDE:
     case kEXTEND:
-    case kPREPEND:
+    case kPREPEND: {
       member = parse_mixin_member(state, true, annot_pos, annotations);
       break;
+    }
 
-    case kALIAS:
+    case kALIAS: {
       member = parse_alias_member(state, true, annot_pos, annotations);
       break;
+    }
 
     default:
       raise_syntax_error(
@@ -2078,6 +2175,7 @@ VALUE parse_interface_members(parserstate *state) {
       );
     }
 
+    melt_array(&members);
     rb_ary_push(members, member);
   }
 
@@ -2087,31 +2185,32 @@ VALUE parse_interface_members(parserstate *state) {
 /*
   interface_decl ::= {`interface`} interface_name module_type_params interface_members <kEND>
 */
-VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annotations) {
-  range member_range;
-  range name_range, keyword_range, end_range;
-  range type_params_range = NULL_RANGE;
+static VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annotations) {
+  parser_push_typevar_table(state, true);
 
+  range member_range;
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
 
-  parser_push_typevar_table(state, true);
-  keyword_range = state->current_token.range;
+  range keyword_range = state->current_token.range;
 
   parser_advance(state);
 
+  range name_range;
   VALUE name = parse_type_name(state, INTERFACE_NAME, &name_range);
+  range type_params_range;
   VALUE params = parse_type_params(state, &type_params_range, true);
   VALUE members = parse_interface_members(state);
 
   parser_advance_assert(state, kEND);
-  end_range = state->current_token.range;
+  range end_range = state->current_token.range;
   member_range.end = end_range.end;
 
   parser_pop_typevar_table(state);
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 4);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2133,35 +2232,35 @@ VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annot
   module_self_type ::= <module_name>
                      | module_name `[` type_list <`]`>
 */
-void parse_module_self_types(parserstate *state, VALUE array) {
+static void parse_module_self_types(parserstate *state, VALUE *array) {
   while (true) {
-    range self_range;
-    range name_range;
-    range args_range = NULL_RANGE;
-
     parser_advance(state);
 
+    range self_range;
     self_range.start = state->current_token.range.start;
-
+    range name_range;
     VALUE module_name = parse_type_name(state, CLASS_NAME | INTERFACE_NAME, &name_range);
     self_range.end = name_range.end;
 
-    VALUE args = rb_ary_new();
+    VALUE args = EMPTY_ARRAY;
+    range args_range = NULL_RANGE;
     if (state->next_token.type == pLBRACKET) {
       parser_advance(state);
       args_range.start = state->current_token.range.start;
-      parse_type_list(state, pRBRACKET, args);
+      parse_type_list(state, pRBRACKET, &args);
       parser_advance(state);
       self_range.end = args_range.end = state->current_token.range.end;
     }
 
     VALUE location = rbs_new_location(state->buffer, self_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
     VALUE self_type = rbs_ast_decl_module_self(module_name, args, location);
-    rb_ary_push(array, self_type);
+    melt_array(array);
+    rb_ary_push(*array, self_type);
 
     if (state->next_token.type == pCOMMA) {
       parser_advance(state);
@@ -2171,7 +2270,7 @@ void parse_module_self_types(parserstate *state, VALUE array) {
   }
 }
 
-VALUE parse_nested_decl(parserstate *state, const char *nested_in, position annot_pos, VALUE annotations);
+static VALUE parse_nested_decl(parserstate *state, const char *nested_in, position annot_pos, VALUE annotations);
 
 /*
   module_members ::= {} ...<module_member> kEND
@@ -2184,59 +2283,65 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
                   | `public`
                   | `private`
 */
-VALUE parse_module_members(parserstate *state) {
-  VALUE members = rb_ary_new();
+static VALUE parse_module_members(parserstate *state) {
+  VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
-    VALUE member;
-    VALUE annotations = rb_ary_new();
+    VALUE annotations = EMPTY_ARRAY;
     position annot_pos = NullPosition;
-
-    parse_annotations(state, annotations, &annot_pos);
+    parse_annotations(state, &annotations, &annot_pos);
 
     parser_advance(state);
 
+    VALUE member;
     switch (state->current_token.type)
     {
-    case kDEF:
+    case kDEF: {
       member = parse_member_def(state, false, true, annot_pos, annotations);
       break;
+    }
 
     case kINCLUDE:
     case kEXTEND:
-    case kPREPEND:
+    case kPREPEND: {
       member = parse_mixin_member(state, false, annot_pos, annotations);
       break;
+    }
 
-    case kALIAS:
+    case kALIAS: {
       member = parse_alias_member(state, false, annot_pos, annotations);
       break;
+    }
 
     case tAIDENT:
     case tA2IDENT:
-    case kSELF:
+    case kSELF: {
       member = parse_variable_member(state, annot_pos, annotations);
       break;
+    }
 
     case kATTRREADER:
     case kATTRWRITER:
-    case kATTRACCESSOR:
+    case kATTRACCESSOR: {
       member = parse_attribute_member(state, annot_pos, annotations);
       break;
+    }
 
     case kPUBLIC:
     case kPRIVATE:
       if (state->next_token.range.start.line == state->current_token.range.start.line) {
         switch (state->next_token.type)
         {
-        case kDEF:
+        case kDEF: {
           member = parse_member_def(state, false, true, annot_pos, annotations);
           break;
+        }
         case kATTRREADER:
         case kATTRWRITER:
-        case kATTRACCESSOR:
+        case kATTRACCESSOR: {
           member = parse_attribute_member(state, annot_pos, annotations);
           break;
+        }
         default:
           raise_syntax_error(state, state->next_token, "method or attribute definition is expected after visibility modifier");
         }
@@ -2250,6 +2355,7 @@ VALUE parse_module_members(parserstate *state) {
       break;
     }
 
+    melt_array(&members);
     rb_ary_push(members, member);
   }
 
@@ -2257,37 +2363,25 @@ VALUE parse_module_members(parserstate *state) {
 }
 
 /*
-  module_decl ::= {`module`} module_name module_type_params module_members <kEND>
-                | {`module`} module_name module_type_params `:` module_self_types module_members <kEND>
+  module_decl ::= {module_name} module_type_params module_members <kEND>
+                | {module_name} module_name module_type_params `:` module_self_types module_members <kEND>
 */
-VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotations) {
-  range decl_range;
-  range keyword_range;
-  range name_range;
-  range end_range;
-  range type_params_range;
-  range colon_range;
-  range self_types_range;
-
+static VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_name, range name_range, VALUE comment, VALUE annotations) {
   parser_push_typevar_table(state, true);
 
-  position start = state->current_token.range.start;
-  comment_pos = nonnull_pos_or(comment_pos, start);
-  VALUE comment = get_comment(state, comment_pos.line);
-
-  keyword_range = state->current_token.range;
-  decl_range.start = state->current_token.range.start;
-
-  parser_advance(state);
-  VALUE module_name = parse_type_name(state, CLASS_NAME, &name_range);
+  range decl_range;
+  decl_range.start = keyword_range.start;
+  range type_params_range;
   VALUE type_params = parse_type_params(state, &type_params_range, true);
-  VALUE self_types = rb_ary_new();
 
+  VALUE self_types = EMPTY_ARRAY;
+  range colon_range;
+  range self_types_range;
   if (state->next_token.type == pCOLON) {
     parser_advance(state);
     colon_range = state->current_token.range;
     self_types_range.start = state->next_token.range.start;
-    parse_module_self_types(state, self_types);
+    parse_module_self_types(state, &self_types);
     self_types_range.end = state->current_token.range.end;
   } else {
     colon_range = NULL_RANGE;
@@ -2297,11 +2391,12 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
   VALUE members = parse_module_members(state);
 
   parser_advance_assert(state, kEND);
-  end_range = state->current_token.range;
+  range end_range = state->current_token.range;
   decl_range.end = state->current_token.range.end;
 
   VALUE location = rbs_new_location(state->buffer, decl_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 6);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2322,31 +2417,69 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
   );
 }
 
+/*
+  module_decl ::= {`module`} module_name `=` old_module_name <kEND>
+                | {`module`} module_name module_decl0 <kEND>
+
+*/
+static VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotations) {
+  range keyword_range = state->current_token.range;
+
+  comment_pos = nonnull_pos_or(comment_pos, state->current_token.range.start);
+  VALUE comment = get_comment(state, comment_pos.line);
+
+  parser_advance(state);
+  range module_name_range;
+  VALUE module_name = parse_type_name(state, CLASS_NAME, &module_name_range);
+
+  if (state->next_token.type == pEQ) {
+    range eq_range = state->next_token.range;
+    parser_advance(state);
+    parser_advance(state);
+
+    range old_name_range;
+    VALUE old_name = parse_type_name(state, CLASS_NAME, &old_name_range);
+
+    range decl_range = {
+      .start = keyword_range.start,
+      .end = old_name_range.end
+    };
+
+    VALUE location = rbs_new_location(state->buffer, decl_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 4);
+    rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
+    rbs_loc_add_required_child(loc, rb_intern("new_name"), module_name_range);
+    rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
+    rbs_loc_add_optional_child(loc, rb_intern("old_name"), old_name_range);
+
+    return rbs_ast_decl_module_alias(module_name, old_name, location, comment);
+  } else {
+    return parse_module_decl0(state, keyword_range, module_name, module_name_range, comment, annotations);
+  }
+}
+
 /*
   class_decl_super ::= {} `<` <class_instance_name>
                      | {<>}
 */
-VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
+static VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
   if (parser_advance_if(state, pLT)) {
-    range super_range;
-    range name_range;
-    range args_range = NULL_RANGE;
-
-    VALUE name;
-    VALUE args;
-    VALUE location;
-    rbs_loc *loc;
-
     *lt_range = state->current_token.range;
+
+    range super_range;
     super_range.start = state->next_token.range.start;
 
-    args = rb_ary_new();
-    class_instance_name(state, CLASS_NAME, &name, args, &name_range, &args_range);
+    VALUE name;
+    VALUE args = EMPTY_ARRAY;
+    range name_range, args_range;
+    class_instance_name(state, CLASS_NAME, &name, &args, &name_range, &args_range);
 
-    super_range.end = args_range.end;
+    super_range.end = state->current_token.range.end;
 
-    location = rbs_new_location(state->buffer, super_range);
-    loc = rbs_check_location(location);
+    VALUE location = rbs_new_location(state->buffer, super_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
@@ -2358,47 +2491,33 @@ VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
 }
 
 /*
-  class_decl ::= {`class`} class_name type_params class_decl_super class_members <`end`>
+  class_decl ::= {class_name} type_params class_decl_super class_members <`end`>
 */
-VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotations) {
-  range decl_range;
-  range keyword_range;
-  range name_range;
-  range end_range;
-  range type_params_range;
-  range lt_range;
-
-  VALUE name;
-  VALUE type_params;
-  VALUE super;
-  VALUE members;
-  VALUE comment;
-  VALUE location;
+static VALUE parse_class_decl0(parserstate *state, range keyword_range, VALUE name, range name_range, VALUE comment, VALUE annotations) {
+  parser_push_typevar_table(state, true);
 
-  rbs_loc *loc;
+  range decl_range;
+  decl_range.start = keyword_range.start;
 
-  parser_push_typevar_table(state, true);
+  range type_params_range;
+  VALUE type_params = parse_type_params(state, &type_params_range, true);
 
-  decl_range.start = state->current_token.range.start;
-  keyword_range = state->current_token.range;
+  range lt_range;
+  VALUE super = parse_class_decl_super(state, &lt_range);
 
-  comment_pos = nonnull_pos_or(comment_pos, decl_range.start);
-  comment = get_comment(state, comment_pos.line);
+  VALUE members = parse_module_members(state);
 
-  parser_advance(state);
-  name = parse_type_name(state, CLASS_NAME, &name_range);
-  type_params = parse_type_params(state, &type_params_range, true);
-  super = parse_class_decl_super(state, &lt_range);
-  members = parse_module_members(state);
   parser_advance_assert(state, kEND);
-  end_range = state->current_token.range;
+
+  range end_range = state->current_token.range;
 
   decl_range.end = end_range.end;
 
   parser_pop_typevar_table(state);
 
-  location = rbs_new_location(state->buffer, decl_range);
-  loc = rbs_check_location(location);
+  VALUE location = rbs_new_location(state->buffer, decl_range);
+  rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2416,6 +2535,47 @@ VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotatio
   );
 }
 
+/*
+  class_decl ::= {`class`} class_name `=` <class_name>
+               | {`class`} class_name <class_decl0>
+*/
+static VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotations) {
+  range keyword_range = state->current_token.range;
+
+  comment_pos = nonnull_pos_or(comment_pos, state->current_token.range.start);
+  VALUE comment = get_comment(state, comment_pos.line);
+
+  parser_advance(state);
+  range class_name_range;
+  VALUE class_name = parse_type_name(state, CLASS_NAME, &class_name_range);
+
+  if (state->next_token.type == pEQ) {
+    range eq_range = state->next_token.range;
+    parser_advance(state);
+    parser_advance(state);
+
+    range old_name_range;
+    VALUE old_name = parse_type_name(state, CLASS_NAME, &old_name_range);
+
+    range decl_range = {
+      .start = keyword_range.start,
+      .end = old_name_range.end,
+    };
+
+    VALUE location = rbs_new_location(state->buffer, decl_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 4);
+    rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
+    rbs_loc_add_required_child(loc, rb_intern("new_name"), class_name_range);
+    rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
+    rbs_loc_add_optional_child(loc, rb_intern("old_name"), old_name_range);
+
+    return rbs_ast_decl_class_alias(class_name, old_name, location, comment);
+  } else {
+    return parse_class_decl0(state, keyword_range, class_name, class_name_range, comment, annotations);
+  }
+}
+
 /*
   nested_decl ::= {<const_decl>}
                 | {<class_decl>}
@@ -2423,31 +2583,36 @@ VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotatio
                 | {<module_decl>}
                 | {<class_decl>}
 */
-VALUE parse_nested_decl(parserstate *state, const char *nested_in, position annot_pos, VALUE annotations) {
-  VALUE decl;
-
+static VALUE parse_nested_decl(parserstate *state, const char *nested_in, position annot_pos, VALUE annotations) {
   parser_push_typevar_table(state, true);
 
+  VALUE decl;
   switch (state->current_token.type) {
   case tUIDENT:
-  case pCOLON2:
+  case pCOLON2: {
     decl = parse_const_decl(state);
     break;
-  case tGIDENT:
+  }
+  case tGIDENT: {
     decl = parse_global_decl(state);
     break;
-  case kTYPE:
+  }
+  case kTYPE: {
     decl = parse_type_decl(state, annot_pos, annotations);
     break;
-  case kINTERFACE:
+  }
+  case kINTERFACE: {
     decl = parse_interface_decl(state, annot_pos, annotations);
     break;
-  case kMODULE:
+  }
+  case kMODULE: {
     decl = parse_module_decl(state, annot_pos, annotations);
     break;
-  case kCLASS:
+  }
+  case kCLASS: {
     decl = parse_class_decl(state, annot_pos, annotations);
     break;
+  }
   default:
     raise_syntax_error(
       state,
@@ -2461,27 +2626,33 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
   return decl;
 }
 
-VALUE parse_decl(parserstate *state) {
-  VALUE annotations = rb_ary_new();
+static VALUE parse_decl(parserstate *state) {
+  VALUE annotations = EMPTY_ARRAY;
   position annot_pos = NullPosition;
 
-  parse_annotations(state, annotations, &annot_pos);
+  parse_annotations(state, &annotations, &annot_pos);
 
   parser_advance(state);
   switch (state->current_token.type) {
   case tUIDENT:
-  case pCOLON2:
+  case pCOLON2: {
     return parse_const_decl(state);
-  case tGIDENT:
+  }
+  case tGIDENT: {
     return parse_global_decl(state);
-  case kTYPE:
+  }
+  case kTYPE: {
     return parse_type_decl(state, annot_pos, annotations);
-  case kINTERFACE:
+  }
+  case kINTERFACE: {
     return parse_interface_decl(state, annot_pos, annotations);
-  case kMODULE:
+  }
+  case kMODULE: {
     return parse_module_decl(state, annot_pos, annotations);
-  case kCLASS:
+  }
+  case kCLASS: {
     return parse_class_decl(state, annot_pos, annotations);
+  }
   default:
     raise_syntax_error(
       state,
@@ -2491,69 +2662,300 @@ VALUE parse_decl(parserstate *state) {
   }
 }
 
+/*
+  namespace ::= {} (`::`)? (`tUIDENT` `::`)* `tUIDENT` <`::`>
+              | {} <>                                            (empty -- returns empty namespace)
+*/
+static VALUE parse_namespace(parserstate *state, range *rg) {
+  bool is_absolute = false;
+
+  if (state->next_token.type == pCOLON2) {
+    *rg = (range) {
+      .start = state->next_token.range.start,
+      .end = state->next_token.range.end,
+    };
+    is_absolute = true;
+
+    parser_advance(state);
+  }
+
+  VALUE path = EMPTY_ARRAY;
+
+  while (true) {
+    if (state->next_token.type == tUIDENT && state->next_token2.type == pCOLON2) {
+      melt_array(&path);
+      rb_ary_push(path, ID2SYM(INTERN_TOKEN(state, state->next_token)));
+      if (null_position_p(rg->start)) {
+        rg->start = state->next_token.range.start;
+      }
+      rg->end = state->next_token2.range.end;
+      parser_advance(state);
+      parser_advance(state);
+    } else {
+      break;
+    }
+  }
+
+  return rbs_namespace(path, is_absolute ? Qtrue : Qfalse);
+}
+
+/*
+  use_clauses ::= {} use_clause `,` ... `,` <use_clause>
+
+  use_clause ::= {} namespace <tUIDENT>
+               | {} namespace tUIDENT `as` <tUIDENT>
+               | {} namespace <tSTAR>
+*/
+static void parse_use_clauses(parserstate *state, VALUE clauses) {
+  while (true) {
+    range namespace_range = NULL_RANGE;
+    VALUE namespace = parse_namespace(state, &namespace_range);
+
+    switch (state->next_token.type)
+    {
+      case tLIDENT:
+      case tULIDENT:
+      case tUIDENT: {
+        parser_advance(state);
+
+        enum TokenType ident_type = state->current_token.type;
+
+        range type_name_range = null_range_p(namespace_range)
+          ? state->current_token.range
+          : (range) { .start = namespace_range.start, .end = state->current_token.range.end };
+
+        VALUE type_name = rbs_type_name(namespace, ID2SYM(INTERN_TOKEN(state, state->current_token)));
+
+        range keyword_range = NULL_RANGE;
+        range new_name_range = NULL_RANGE;
+
+        VALUE new_name = Qnil;
+        range clause_range = type_name_range;
+        if (state->next_token.type == kAS) {
+          parser_advance(state);
+          keyword_range = state->current_token.range;
+
+          if (ident_type == tUIDENT) parser_advance_assert(state, tUIDENT);
+          if (ident_type == tLIDENT) parser_advance_assert(state, tLIDENT);
+          if (ident_type == tULIDENT) parser_advance_assert(state, tULIDENT);
+
+          new_name = ID2SYM(INTERN_TOKEN(state, state->current_token));
+          new_name_range = state->current_token.range;
+          clause_range.end = new_name_range.end;
+        }
+
+        VALUE location = rbs_new_location(state->buffer, clause_range);
+        rbs_loc *loc = rbs_check_location(location);
+        rbs_loc_alloc_children(loc, 3);
+        rbs_loc_add_required_child(loc, rb_intern("type_name"), type_name_range);
+        rbs_loc_add_optional_child(loc, rb_intern("keyword"), keyword_range);
+        rbs_loc_add_optional_child(loc, rb_intern("new_name"), new_name_range);
+
+        rb_ary_push(clauses, rbs_ast_directives_use_single_clause(type_name, new_name, location));
+
+        break;
+      }
+      case pSTAR:
+      {
+        range clause_range = namespace_range;
+        parser_advance(state);
+
+        range star_range = state->current_token.range;
+        clause_range.end = star_range.end;
+
+        VALUE location = rbs_new_location(state->buffer, clause_range);
+        rbs_loc *loc = rbs_check_location(location);
+        rbs_loc_alloc_children(loc, 2);
+        rbs_loc_add_required_child(loc, rb_intern("namespace"), namespace_range);
+        rbs_loc_add_required_child(loc, rb_intern("star"), star_range);
+
+        rb_ary_push(clauses, rbs_ast_directives_use_wildcard_clause(namespace, location));
+
+        break;
+      }
+      default:
+        raise_syntax_error(
+          state,
+          state->next_token,
+          "use clause is expected"
+        );
+    }
+
+    if (state->next_token.type == pCOMMA) {
+      parser_advance(state);
+    } else {
+      break;
+    }
+  }
+
+  return;
+}
+
+/*
+  use_directive ::= {} `use` <clauses>
+ */
+static VALUE parse_use_directive(parserstate *state) {
+  if (state->next_token.type == kUSE) {
+    parser_advance(state);
+
+    range keyword_range = state->current_token.range;
+
+    VALUE clauses = rb_ary_new();
+    parse_use_clauses(state, clauses);
+
+    range directive_range = keyword_range;
+    directive_range.end = state->current_token.range.end;
+
+    VALUE location = rbs_new_location(state->buffer, directive_range);
+    rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
+    rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
+
+    return rbs_ast_directives_use(clauses, location);
+  } else {
+    return Qnil;
+  }
+}
+
 VALUE parse_signature(parserstate *state) {
-  VALUE decls = rb_ary_new();
+  VALUE dirs = EMPTY_ARRAY;
+  VALUE decls = EMPTY_ARRAY;
+
+  while (state->next_token.type == kUSE) {
+    melt_array(&dirs);
+    rb_ary_push(dirs, parse_use_directive(state));
+  }
 
   while (state->next_token.type != pEOF) {
+    melt_array(&decls);
     rb_ary_push(decls, parse_decl(state));
   }
 
-  return decls;
+  VALUE ret = rb_ary_new();
+  rb_ary_push(ret, dirs);
+  rb_ary_push(ret, decls);
+  return ret;
 }
 
+struct parse_type_arg {
+  parserstate *parser;
+  VALUE require_eof;
+};
+
 static VALUE
-rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE requires_eof)
-{
-  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+ensure_free_parser(VALUE parser) {
+  free_parser((parserstate *)parser);
+  return Qnil;
+}
+
+static VALUE
+parse_type_try(VALUE a) {
+  struct parse_type_arg *arg = (struct parse_type_arg *)a;
 
-  if (parser->next_token.type == pEOF) {
+  if (arg->parser->next_token.type == pEOF) {
     return Qnil;
   }
 
-  VALUE type = parse_type(parser);
+  VALUE type = parse_type(arg->parser);
 
-  if (RTEST(requires_eof)) {
-    parser_advance_assert(parser, pEOF);
+  if (RB_TEST(arg->require_eof)) {
+    parser_advance_assert(arg->parser, pEOF);
   }
 
-  free_parser(parser);
-
   return type;
 }
 
 static VALUE
-rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE requires_eof)
+rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, FIX2INT(start_pos), FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+  struct parse_type_arg arg = {
+    parser,
+    require_eof
+  };
+  return rb_ensure(parse_type_try, (VALUE)&arg, ensure_free_parser, (VALUE)parser);
+}
+
+static VALUE
+parse_method_type_try(VALUE a) {
+  struct parse_type_arg *arg = (struct parse_type_arg *)a;
 
-  if (parser->next_token.type == pEOF) {
+  if (arg->parser->next_token.type == pEOF) {
     return Qnil;
   }
 
-  VALUE method_type = parse_method_type(parser);
+  VALUE method_type = parse_method_type(arg->parser);
 
-  if (RTEST(requires_eof)) {
-    parser_advance_assert(parser, pEOF);
+  if (RB_TEST(arg->require_eof)) {
+    parser_advance_assert(arg->parser, pEOF);
   }
 
-  free_parser(parser);
-
   return method_type;
 }
 
+static VALUE
+rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof)
+{
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, FIX2INT(start_pos), FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+  struct parse_type_arg arg = {
+    parser,
+    require_eof
+  };
+  return rb_ensure(parse_method_type_try, (VALUE)&arg, ensure_free_parser, (VALUE)parser);
+}
+
+static VALUE
+parse_signature_try(VALUE a) {
+  parserstate *parser = (parserstate *)a;
+  return parse_signature(parser);
+}
+
 static VALUE
 rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE end_pos)
 {
-  parserstate *parser = alloc_parser(buffer, 0, FIX2INT(end_pos), Qnil);
-  VALUE signature = parse_signature(parser);
-  free_parser(parser);
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, 0, FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, 0, FIX2INT(end_pos), Qnil);
+  return rb_ensure(parse_signature_try, (VALUE)parser, ensure_free_parser, (VALUE)parser);
+}
+
+static VALUE
+rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, 0, FIX2INT(end_pos));
+  VALUE results = rb_ary_new();
 
-  return signature;
+  token token = NullToken;
+  while (token.type != pEOF) {
+    token = rbsparser_next_token(lexer);
+    VALUE type = ID2SYM(rb_intern(token_type_str(token.type)));
+    VALUE location = rbs_new_location(buffer, token.range);
+    VALUE pair = rb_ary_new3(2, type, location);
+    rb_ary_push(results, pair);
+  }
+
+  free(lexer);
+
+  return results;
 }
 
 void rbs__init_parser(void) {
   RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
+  rb_gc_register_mark_object(RBS_Parser);
+  VALUE empty_array = rb_obj_freeze(rb_ary_new());
+  rb_gc_register_mark_object(empty_array);
+  EMPTY_ARRAY = empty_array;
+
   rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 2);
+  rb_define_singleton_method(RBS_Parser, "_lex", rbsparser_lex, 2);
 }