rbs 3.6.1 → 3.9.5

data/ext/rbs_extension/parser.c

@@ -1,4 +1,12 @@
 #include "rbs_extension.h"
+#include "rbs/util/rbs_constant_pool.h"
+
+#define INTERN(str)                  \
+  rbs_constant_pool_insert_constant( \
+    RBS_GLOBAL_CONSTANT_POOL,        \
+    (const uint8_t *) str,           \
+    strlen(str)                      \
+  )
 
 #define INTERN_TOKEN(parserstate, tok) \
   rb_intern3(\
@@ -53,13 +61,20 @@ typedef struct {
 } method_params;
 
 static VALUE EMPTY_ARRAY;
+static VALUE EMPTY_HASH;
 
-static void inline melt_array(VALUE *array) {
+static inline void melt_array(VALUE *array) {
   if (*array == EMPTY_ARRAY) {
     *array = rb_ary_new();
   }
 }
 
+static inline void melt_hash(VALUE *hash) {
+  if (*hash == EMPTY_HASH) {
+    *hash = rb_hash_new();
+  }
+}
+
 static bool rbs_is_untyped_params(method_params *params) {
   return NIL_P(params->required_positionals);
 }
@@ -143,10 +158,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 = EMPTY_ARRAY;
-  VALUE namespace;
 
   if (rg) {
     rg->start = state->current_token.range.start;
@@ -169,7 +183,8 @@ VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
     parser_advance(state);
     parser_advance(state);
   }
-  namespace = rbs_namespace(path, absolute);
+
+  VALUE namespace = rbs_namespace(path, absolute);
 
   switch (state->current_token.type) {
     case tLIDENT:
@@ -267,7 +282,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;
@@ -278,16 +292,18 @@ 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);
+    rbs_loc_add_optional_child(loc, 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(
@@ -301,7 +317,7 @@ 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"), name_range);
+    rbs_loc_add_optional_child(loc, INTERN("name"), name_range);
 
     return rbs_function_param(type, name, location);
   }
@@ -320,28 +336,22 @@ 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 memo) {
-  VALUE key;
-  VALUE param;
-
-  key = parse_keyword_key(state);
+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(
@@ -354,9 +364,10 @@ static void parse_keyword(parserstate *state, VALUE keywords, VALUE memo) {
   }
 
   parser_advance_assert(state, pCOLON);
-  param = parse_function_param(state);
+  VALUE param = parse_function_param(state);
 
-  rb_hash_aset(keywords, key, param);
+  melt_hash(keywords);
+  rb_hash_aset(*keywords, key, param);
 
   return;
 }
@@ -463,7 +474,7 @@ PARSE_OPTIONAL_PARAMS:
         parser_advance(state);
 
         if (is_keyword(state)) {
-          parse_keyword(state, params->optional_keywords, memo);
+          parse_keyword(state, &params->optional_keywords, memo);
           parser_advance_if(state, pCOMMA);
           goto PARSE_KEYWORDS;
         }
@@ -530,7 +541,7 @@ PARSE_KEYWORDS:
     case pQUESTION:
       parser_advance(state);
       if (is_keyword(state)) {
-        parse_keyword(state, params->optional_keywords, memo);
+        parse_keyword(state, &params->optional_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -553,7 +564,7 @@ PARSE_KEYWORDS:
     case tBANGIDENT:
     KEYWORD_CASES
       if (is_keyword(state)) {
-        parse_keyword(state, params->required_keywords, memo);
+        parse_keyword(state, &params->required_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -591,6 +602,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) {
@@ -604,13 +616,15 @@ static VALUE parse_optional(parserstate *state) {
 }
 
 static void initialize_method_params(method_params *params){
-  params->required_positionals = EMPTY_ARRAY;
-  params->optional_positionals = EMPTY_ARRAY;
-  params->rest_positionals = Qnil;
-  params->trailing_positionals = EMPTY_ARRAY;
-  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 = EMPTY_HASH,
+    .optional_keywords = EMPTY_HASH,
+    .rest_keywords = Qnil,
+  };
 }
 
 /*
@@ -647,16 +661,16 @@ 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);
+  } else {
+    // Parsing method type. untyped_params means it cannot have a 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");
+      }
+    }
   }
 
   VALUE required = Qtrue;
@@ -757,7 +771,7 @@ static void check_key_duplication(parserstate *state, VALUE fields, VALUE key) {
   record_attribute ::= {} keyword_token `:` <type>
                      | {} literal_type `=>` <type>
 */
-VALUE parse_record_attributes(parserstate *state) {
+static VALUE parse_record_attributes(parserstate *state) {
   VALUE fields = rb_hash_new();
 
   if (state->next_token.type == pRBRACE) {
@@ -790,9 +804,10 @@ VALUE parse_record_attributes(parserstate *state) {
       case tDQSTRING:
       case tINTEGER:
       case kTRUE:
-      case kFALSE:
+      case kFALSE: {
         key = rb_funcall(parse_simple(state), rb_intern("literal"), 0);
         break;
+      }
       default:
         raise_syntax_error(
           state,
@@ -864,15 +879,12 @@ 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 = EMPTY_ARRAY;
 
@@ -887,6 +899,7 @@ 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;
@@ -897,14 +910,16 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
       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);
+    rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+    rbs_loc_add_optional_child(loc, INTERN("args"), args_range);
 
     if (kind == CLASS_NAME) {
       return rbs_class_instance(typename, types, location);
@@ -921,15 +936,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);
@@ -938,7 +952,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);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
 
   return rbs_class_singleton(typename, location);
 }
@@ -962,28 +976,35 @@ 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(false, rbs_location_current_token(state));
+  }
   case k__TODO__: {
-    VALUE type = rbs_base_type(RBS_Types_Bases_Any, rbs_location_current_token(state));
-    rb_funcall(type, rb_intern("todo!"), 0);
-    return type;
+    return rbs_bases_any(true, rbs_location_current_token(state));
   }
   case tINTEGER: {
     VALUE literal = rb_funcall(
@@ -996,10 +1017,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);
@@ -1014,18 +1037,25 @@ static VALUE parse_simple(parserstate *state) {
     return parse_symbol(state);
   }
   case tUIDENT: {
-    ID name = INTERN_TOKEN(state, state->current_token);
+    const char *name_str = peek_token(state->lexstate, state->current_token);
+    size_t name_len = token_bytes(state->current_token);
+
+    rbs_constant_id_t name = rbs_constant_pool_find(&state->constant_pool, (const uint8_t *) name_str, name_len);
+
     if (parser_typevar_member(state, name)) {
+      ID name = rb_intern3(name_str, name_len, rb_enc_get(state->lexstate->string));
       return rbs_variable(ID2SYM(name), rbs_location_current_token(state));
     }
     // fallthrough for type name
   }
   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;
@@ -1066,26 +1096,24 @@ static VALUE parse_simple(parserstate *state) {
                  | {} <optional>
 */
 static VALUE parse_intersection(parserstate *state) {
-  range rg;
-
-  rg.start = state->next_token.range.start;
+  position start = state->next_token.range.start;
   VALUE type = parse_optional(state);
-  VALUE intersection_types = rb_ary_new();
+  if (state->next_token.type != pAMP) {
+    return type;
+  }
 
+  VALUE intersection_types = rb_ary_new();
   rb_ary_push(intersection_types, type);
   while (state->next_token.type == pAMP) {
     parser_advance(state);
     rb_ary_push(intersection_types, parse_optional(state));
   }
-
-  rg.end = state->current_token.range.end;
-
-  if (rb_array_len(intersection_types) > 1) {
-    VALUE location = rbs_new_location(state->buffer, rg);
-    type = rbs_intersection(intersection_types, location);
-  }
-
-  return type;
+  range rg = (range) {
+    .start = start,
+    .end = state->current_token.range.end,
+  };
+  VALUE location = rbs_new_location(state->buffer, rg);
+  return rbs_intersection(intersection_types, location);
 }
 
 /*
@@ -1093,26 +1121,24 @@ static VALUE parse_intersection(parserstate *state) {
           | {} <intersection>
 */
 VALUE parse_type(parserstate *state) {
-  range rg;
-
-  rg.start = state->next_token.range.start;
+  position start = state->next_token.range.start;
   VALUE type = parse_intersection(state);
-  VALUE union_types = rb_ary_new();
+  if (state->next_token.type != pBAR) {
+    return type;
+  }
 
+  VALUE union_types = rb_ary_new();
   rb_ary_push(union_types, type);
   while (state->next_token.type == pBAR) {
     parser_advance(state);
     rb_ary_push(union_types, parse_intersection(state));
   }
-
-  rg.end = state->current_token.range.end;
-
-  if (rb_array_len(union_types) > 1) {
-    VALUE location = rbs_new_location(state->buffer, rg);
-    type = rbs_union(union_types, location);
-  }
-
-  return type;
+  range rg = (range) {
+    .start = start,
+    .end = state->current_token.range.end,
+  };
+  VALUE location = rbs_new_location(state->buffer, rg);
+  return rbs_union(union_types, location);
 }
 
 /*
@@ -1123,7 +1149,7 @@ VALUE parse_type(parserstate *state) {
 
   type_param ::= tUIDENT upper_bound? default_type?                           (module_type_params == false)
 */
-VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
+static VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
   VALUE params = EMPTY_ARRAY;
 
   bool required_param_allowed = true;
@@ -1134,24 +1160,19 @@ 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 unchecked = Qfalse;
       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 default_type_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;
+          unchecked = Qtrue;
           parser_advance(state);
           unchecked_range = state->current_token.range;
         }
@@ -1174,13 +1195,19 @@ 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;
+
+      rbs_constant_id_t id = rbs_constant_pool_insert_shared(
+        &state->constant_pool,
+        (const uint8_t *) peek_token(state->lexstate, state->current_token),
+        token_bytes(state->current_token)
+      );
 
-      ID id = INTERN_TOKEN(state, state->current_token);
-      name = ID2SYM(id);
+      VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
       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;
@@ -1188,6 +1215,7 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
         upper_bound_range.end = state->current_token.range.end;
       }
 
+      range default_type_range = NULL_RANGE;
       if (module_type_params) {
         if (state->next_token.type == pEQ) {
           parser_advance(state);
@@ -1212,14 +1240,15 @@ 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, 4);
-      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, unchecked, upper_bound, default_type, location);
+      rbs_loc_alloc_children(loc, 5);
+      rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+      rbs_loc_add_optional_child(loc, INTERN("variance"), variance_range);
+      rbs_loc_add_optional_child(loc, INTERN("unchecked"), unchecked_range);
+      rbs_loc_add_optional_child(loc, INTERN("upper_bound"), upper_bound_range);
+      rbs_loc_add_optional_child(loc, INTERN("default"), default_type_range);
+
+      VALUE param = rbs_ast_type_param(name, variance, upper_bound, default_type, unchecked, location);
+
       melt_array(&params);
       rb_ary_push(params, param);
 
@@ -1252,20 +1281,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;
@@ -1276,8 +1304,8 @@ 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);
+  rbs_loc_add_required_child(loc, INTERN("type"), type_range);
+  rbs_loc_add_optional_child(loc, INTERN("type_params"), params_range);
 
   return rbs_method_type(
     type_params,
@@ -1290,93 +1318,78 @@ VALUE parse_method_type(parserstate *state) {
 /*
   global_decl ::= {tGIDENT} `:` <type>
 */
-VALUE parse_global_decl(parserstate *state) {
+static VALUE parse_global_decl(parserstate *state, VALUE annotations) {
   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);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
 
-  return rbs_ast_decl_global(typename, type, location, comment);
+  return rbs_ast_decl_global(typename, type, location, comment, annotations);
 }
 
 /*
   const_decl ::= {const_name} `:` <type>
 */
-VALUE parse_const_decl(parserstate *state) {
+static VALUE parse_const_decl(parserstate *state, VALUE annotations) {
   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);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
 
-  return rbs_ast_decl_constant(typename, type, location, comment);
+  return rbs_ast_decl_constant(typename, type, location, comment, annotations);
 }
 
 /*
   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;
@@ -1384,10 +1397,10 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
   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);
-  rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_optional_child(loc, INTERN("type_params"), params_range);
+  rbs_loc_add_required_child(loc, INTERN("eq"), eq_range);
 
   parser_pop_typevar_table(state);
 
@@ -1404,7 +1417,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);
 
@@ -1460,7 +1473,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) {
@@ -1483,7 +1496,7 @@ void parse_annotations(parserstate *state, VALUE *annotations, position *annot_p
   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)
@@ -1515,8 +1528,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:
@@ -1551,7 +1565,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) {
@@ -1561,8 +1575,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
@@ -1572,9 +1584,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;
   }
@@ -1594,42 +1609,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 overloading_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;
@@ -1638,6 +1651,7 @@ 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 overloads = rb_ary_new();
   VALUE overloading = Qfalse;
@@ -1654,6 +1668,7 @@ 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;
@@ -1727,11 +1742,11 @@ 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("overloading"), overloading_range);
-  rbs_loc_add_optional_child(loc, rb_intern("visibility"), visibility_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_optional_child(loc, INTERN("kind"), kind_range);
+  rbs_loc_add_optional_child(loc, INTERN("overloading"), overloading_range);
+  rbs_loc_add_optional_child(loc, INTERN("visibility"), visibility_range);
 
   return rbs_ast_members_method_definition(
     name,
@@ -1774,31 +1789,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:
@@ -1819,6 +1827,8 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
 
   VALUE name;
   VALUE args = EMPTY_ARRAY;
+  range name_range;
+  range args_range = NULL_RANGE;
   class_instance_name(
     state,
     from_interface ? INTERFACE_NAME : (INTERFACE_NAME | CLASS_NAME),
@@ -1832,18 +1842,22 @@ 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);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_optional_child(loc, 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();
+  }
 }
 
 /**
@@ -1854,21 +1868,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"));
 
@@ -1896,11 +1905,11 @@ VALUE parse_alias_member(parserstate *state, bool instance_only, position commen
   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);
-  rbs_loc_add_optional_child(loc, rb_intern("new_kind"), new_kind_range);
-  rbs_loc_add_optional_child(loc, rb_intern("old_kind"), old_kind_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("new_name"), new_name_range);
+  rbs_loc_add_required_child(loc, INTERN("old_name"), old_name_range);
+  rbs_loc_add_optional_child(loc, INTERN("new_kind"), new_kind_range);
+  rbs_loc_add_optional_child(loc, INTERN("old_kind"), old_kind_range);
 
   return rbs_ast_members_alias(
     new_name,
@@ -1917,11 +1926,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,
@@ -1930,88 +1935,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, INTERN("name"), name_range);
+    rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, 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, INTERN("name"), name_range);
+    rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, 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, INTERN("name"), name_range);
+    rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
+    rbs_loc_add_optional_child(loc, 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_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_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,
@@ -2020,24 +2029,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)
-  );
 }
 
 /*
@@ -2054,26 +2056,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:
@@ -2092,31 +2082,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;
@@ -2126,44 +2103,47 @@ 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);
-  rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
-  rbs_loc_add_optional_child(loc, rb_intern("ivar"), ivar_range);
-  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
-  );
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("colon"), colon_range);
+  rbs_loc_add_optional_child(loc, INTERN("kind"), kind_range);
+  rbs_loc_add_optional_child(loc, INTERN("ivar"), ivar_range);
+  rbs_loc_add_optional_child(loc, INTERN("ivar_name"), ivar_name_range);
+  rbs_loc_add_optional_child(loc, INTERN("visibility"), visibility_range);
+
+  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();
+  }
 }
 
 /*
@@ -2173,7 +2153,7 @@ 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) {
+static VALUE parse_interface_members(parserstate *state) {
   VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
@@ -2186,19 +2166,22 @@ VALUE parse_interface_members(parserstate *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(
@@ -2218,25 +2201,25 @@ 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);
@@ -2244,10 +2227,10 @@ VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annot
   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);
-  rbs_loc_add_optional_child(loc, rb_intern("type_params"), type_params_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("end"), end_range);
+  rbs_loc_add_optional_child(loc, INTERN("type_params"), type_params_range);
 
   return rbs_ast_decl_interface(
     name,
@@ -2265,20 +2248,18 @@ 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 = EMPTY_ARRAY;
+    range args_range = NULL_RANGE;
     if (state->next_token.type == pLBRACKET) {
       parser_advance(state);
       args_range.start = state->current_token.range.start;
@@ -2290,8 +2271,8 @@ void parse_module_self_types(parserstate *state, VALUE *array) {
     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);
+    rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+    rbs_loc_add_optional_child(loc, INTERN("args"), args_range);
 
     VALUE self_type = rbs_ast_decl_module_self(module_name, args, location);
     melt_array(array);
@@ -2305,7 +2286,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
@@ -2318,59 +2299,65 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
                   | `public`
                   | `private`
 */
-VALUE parse_module_members(parserstate *state) {
+static VALUE parse_module_members(parserstate *state) {
   VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
-    VALUE member;
     VALUE annotations = EMPTY_ARRAY;
     position annot_pos = NullPosition;
-
     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");
         }
@@ -2395,20 +2382,17 @@ VALUE parse_module_members(parserstate *state) {
   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_decl0(parserstate *state, range keyword_range, VALUE module_name, range name_range, VALUE comment, VALUE annotations) {
-  range decl_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);
 
+  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 = EMPTY_ARRAY;
 
+  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;
@@ -2423,18 +2407,18 @@ VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_n
   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);
-  rbs_loc_add_optional_child(loc, rb_intern("type_params"), type_params_range);
-  rbs_loc_add_optional_child(loc, rb_intern("colon"), colon_range);
-  rbs_loc_add_optional_child(loc, rb_intern("self_types"), self_types_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("end"), end_range);
+  rbs_loc_add_optional_child(loc, INTERN("type_params"), type_params_range);
+  rbs_loc_add_optional_child(loc, INTERN("colon"), colon_range);
+  rbs_loc_add_optional_child(loc, INTERN("self_types"), self_types_range);
 
   parser_pop_typevar_table(state);
 
@@ -2454,14 +2438,14 @@ VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_n
                 | {`module`} module_name module_decl0 <kEND>
 
 */
-VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotations) {
+static VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotations) {
   range keyword_range = state->current_token.range;
-  range module_name_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) {
@@ -2472,19 +2456,20 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
     range old_name_range;
     VALUE old_name = parse_type_name(state, CLASS_NAME, &old_name_range);
 
-    range decl_range;
-    decl_range.start = keyword_range.start;
-    decl_range.end = old_name_range.end;
+    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);
+    rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+    rbs_loc_add_required_child(loc, INTERN("new_name"), module_name_range);
+    rbs_loc_add_required_child(loc, INTERN("eq"), eq_range);
+    rbs_loc_add_optional_child(loc, INTERN("old_name"), old_name_range);
 
-    return rbs_ast_decl_module_alias(module_name, old_name, location, comment);
+    return rbs_ast_decl_module_alias(module_name, old_name, location, comment, annotations);
   } else {
     return parse_module_decl0(state, keyword_range, module_name, module_name_range, comment, annotations);
   }
@@ -2494,30 +2479,25 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
   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 = EMPTY_ARRAY;
+    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 = 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);
+    rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+    rbs_loc_add_optional_child(loc, INTERN("args"), args_range);
 
     return rbs_ast_decl_class_super(name, args, location);
   } else {
@@ -2529,41 +2509,36 @@ VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
 /*
   class_decl ::= {class_name} type_params class_decl_super class_members <`end`>
 */
-VALUE parse_class_decl0(parserstate *state, range keyword_range, VALUE name, range name_range, VALUE comment, VALUE annotations) {
-  range decl_range;
-  range end_range;
-  range type_params_range;
-  range lt_range;
+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);
 
-  VALUE type_params;
-  VALUE super;
-  VALUE members;
-  VALUE location;
+  range decl_range;
+  decl_range.start = keyword_range.start;
 
-  rbs_loc *loc;
+  range type_params_range;
+  VALUE type_params = parse_type_params(state, &type_params_range, true);
 
-  parser_push_typevar_table(state, true);
+  range lt_range;
+  VALUE super = parse_class_decl_super(state, &lt_range);
 
-  decl_range.start = keyword_range.start;
+  VALUE members = parse_module_members(state);
 
-  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);
-  rbs_loc_add_optional_child(loc, rb_intern("type_params"), type_params_range);
-  rbs_loc_add_optional_child(loc, rb_intern("lt"), lt_range);
+  rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+  rbs_loc_add_required_child(loc, INTERN("name"), name_range);
+  rbs_loc_add_required_child(loc, INTERN("end"), end_range);
+  rbs_loc_add_optional_child(loc, INTERN("type_params"), type_params_range);
+  rbs_loc_add_optional_child(loc, INTERN("lt"), lt_range);
 
   return rbs_ast_decl_class(
     name,
@@ -2580,14 +2555,14 @@ VALUE parse_class_decl0(parserstate *state, range keyword_range, VALUE name, ran
   class_decl ::= {`class`} class_name `=` <class_name>
                | {`class`} class_name <class_decl0>
 */
-VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotations) {
+static VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotations) {
   range keyword_range = state->current_token.range;
-  range class_name_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) {
@@ -2598,19 +2573,20 @@ VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotatio
     range old_name_range;
     VALUE old_name = parse_type_name(state, CLASS_NAME, &old_name_range);
 
-    range decl_range;
-    decl_range.start = keyword_range.start;
-    decl_range.end = old_name_range.end;
+    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);
+    rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
+    rbs_loc_add_required_child(loc, INTERN("new_name"), class_name_range);
+    rbs_loc_add_required_child(loc, INTERN("eq"), eq_range);
+    rbs_loc_add_optional_child(loc, INTERN("old_name"), old_name_range);
 
-    return rbs_ast_decl_class_alias(class_name, old_name, location, comment);
+    return rbs_ast_decl_class_alias(class_name, old_name, location, comment, annotations);
   } else {
     return parse_class_decl0(state, keyword_range, class_name, class_name_range, comment, annotations);
   }
@@ -2623,31 +2599,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:
-    decl = parse_const_decl(state);
+  case pCOLON2: {
+    decl = parse_const_decl(state, annotations);
     break;
-  case tGIDENT:
-    decl = parse_global_decl(state);
+  }
+  case tGIDENT: {
+    decl = parse_global_decl(state, annotations);
     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,
@@ -2661,7 +2642,7 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
   return decl;
 }
 
-VALUE parse_decl(parserstate *state) {
+static VALUE parse_decl(parserstate *state) {
   VALUE annotations = EMPTY_ARRAY;
   position annot_pos = NullPosition;
 
@@ -2670,18 +2651,24 @@ VALUE parse_decl(parserstate *state) {
   parser_advance(state);
   switch (state->current_token.type) {
   case tUIDENT:
-  case pCOLON2:
-    return parse_const_decl(state);
-  case tGIDENT:
-    return parse_global_decl(state);
-  case kTYPE:
+  case pCOLON2: {
+    return parse_const_decl(state, annotations);
+  }
+  case tGIDENT: {
+    return parse_global_decl(state, annotations);
+  }
+  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,
@@ -2695,12 +2682,14 @@ VALUE parse_decl(parserstate *state) {
   namespace ::= {} (`::`)? (`tUIDENT` `::`)* `tUIDENT` <`::`>
               | {} <>                                            (empty -- returns empty namespace)
 */
-VALUE parse_namespace(parserstate *state, range *rg) {
+static VALUE parse_namespace(parserstate *state, range *rg) {
   bool is_absolute = false;
 
   if (state->next_token.type == pCOLON2) {
-    rg->start = state->next_token.range.start;
-    rg->end = state->next_token.range.end;
+    *rg = (range) {
+      .start = state->next_token.range.start,
+      .end = state->next_token.range.end,
+    };
     is_absolute = true;
 
     parser_advance(state);
@@ -2733,13 +2722,11 @@ VALUE parse_namespace(parserstate *state, range *rg) {
                | {} namespace tUIDENT `as` <tUIDENT>
                | {} namespace <tSTAR>
 */
-void parse_use_clauses(parserstate *state, VALUE clauses) {
+static void parse_use_clauses(parserstate *state, VALUE clauses) {
   while (true) {
     range namespace_range = NULL_RANGE;
     VALUE namespace = parse_namespace(state, &namespace_range);
 
-    range clause_range = namespace_range;
-
     switch (state->next_token.type)
     {
       case tLIDENT:
@@ -2749,14 +2736,9 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
 
         enum TokenType ident_type = state->current_token.type;
 
-        range type_name_range;
-        if (null_range_p(namespace_range)) {
-          type_name_range = state->current_token.range;
-        } else {
-          type_name_range.start = namespace_range.start;
-          type_name_range.end = state->current_token.range.end;
-        }
-        clause_range = type_name_range;
+        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)));
 
@@ -2764,6 +2746,7 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
         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;
@@ -2780,9 +2763,9 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
         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);
+        rbs_loc_add_required_child(loc, INTERN("type_name"), type_name_range);
+        rbs_loc_add_optional_child(loc, INTERN("keyword"), keyword_range);
+        rbs_loc_add_optional_child(loc, INTERN("new_name"), new_name_range);
 
         rb_ary_push(clauses, rbs_ast_directives_use_single_clause(type_name, new_name, location));
 
@@ -2790,6 +2773,7 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
       }
       case pSTAR:
       {
+        range clause_range = namespace_range;
         parser_advance(state);
 
         range star_range = state->current_token.range;
@@ -2798,8 +2782,8 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
         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);
+        rbs_loc_add_required_child(loc, INTERN("namespace"), namespace_range);
+        rbs_loc_add_required_child(loc, INTERN("star"), star_range);
 
         rb_ary_push(clauses, rbs_ast_directives_use_wildcard_clause(namespace, location));
 
@@ -2826,7 +2810,7 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
 /*
   use_directive ::= {} `use` <clauses>
  */
-VALUE parse_use_directive(parserstate *state) {
+static VALUE parse_use_directive(parserstate *state) {
   if (state->next_token.type == kUSE) {
     parser_advance(state);
 
@@ -2841,7 +2825,7 @@ VALUE parse_use_directive(parserstate *state) {
     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);
+    rbs_loc_add_required_child(loc, INTERN("keyword"), keyword_range);
 
     return rbs_ast_directives_use(clauses, location);
   } else {
@@ -2949,12 +2933,12 @@ parse_signature_try(VALUE a) {
 }
 
 static VALUE
-rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE end_pos)
+rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos)
 {
   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);
+  lexstate *lexer = alloc_lexer(string, FIX2INT(start_pos), FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, FIX2INT(start_pos), FIX2INT(end_pos), Qnil);
   return rb_ensure(parse_signature_try, (VALUE)parser, ensure_free_parser, (VALUE)parser);
 }
 
@@ -2982,12 +2966,17 @@ rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
 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;
 
+  VALUE empty_hash = rb_obj_freeze(rb_hash_new());
+  rb_gc_register_mark_object(empty_hash);
+  EMPTY_HASH = empty_hash;
+
   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, "_parse_signature", rbsparser_parse_signature, 3);
   rb_define_singleton_method(RBS_Parser, "_lex", rbsparser_lex, 2);
 }