rbs 2.8.4 → 3.0.0.dev.2

data/ext/rbs_extension/lexer.h

@@ -58,6 +58,8 @@ enum TokenType {
   kUNCHECKED,       /* unchecked */
   kUNTYPED,         /* untyped */
   kVOID,            /* void */
+  kUSE,             /* use */
+  kAS,              /* as */
 
   tLIDENT,          /* Identifiers starting with lower case */
   tUIDENT,          /* Identifiers starting with upper case */
@@ -150,7 +152,7 @@ unsigned int peek(lexstate *state);
 /**
  * Skip one character.
  * */
-void skip(lexstate *state);
+void rbs_skip(lexstate *state);
 
 /**
  * Skip n characters.

data/ext/rbs_extension/lexer.re

@@ -12,7 +12,7 @@ start:
       re2c:flags:input = custom;
       re2c:define:YYCTYPE = "unsigned int";
       re2c:define:YYPEEK = "peek(state)";
-      re2c:define:YYSKIP = "skip(state);";
+      re2c:define:YYSKIP = "rbs_skip(state);";
       re2c:define:YYBACKUP = "backup = *state;";
       re2c:define:YYRESTORE = "*state = backup;";
       re2c:yyfill:enable  = 0;
@@ -93,6 +93,8 @@ start:
       "unchecked"     { return next_token(state, kUNCHECKED); }
       "untyped"       { return next_token(state, kUNTYPED); }
       "void"          { return next_token(state, kVOID); }
+      "use"           { return next_token(state, kUSE); }
+      "as"            { return next_token(state, kAS); }
 
       dqstring = ["] ("\\"[abefnrstv"\\] | [^"\\\x00])* ["];
       sqstring = ['] ("\\"['\\] | [^'\x00])* ['];

data/ext/rbs_extension/lexstate.c

@@ -57,6 +57,8 @@ static const char *RBS_TOKENTYPE_NAMES[] = {
   "kUNCHECKED",       /* unchecked */
   "kUNTYPED",         /* untyped */
   "kVOID",            /* void */
+  "kUSE",             /* use */
+  "kAS",              /* as */
 
   "tLIDENT",          /* Identifiers starting with lower case */
   "tUIDENT",          /* Identifiers starting with upper case */
@@ -122,7 +124,7 @@ token next_token(lexstate *state, enum TokenType type) {
   return t;
 }
 
-void skip(lexstate *state) {
+void rbs_skip(lexstate *state) {
   if (!state->last_char) {
     peek(state);
   }
@@ -143,7 +145,7 @@ void skip(lexstate *state) {
 void skipn(lexstate *state, size_t size) {
   for (size_t i = 0; i < size; i ++) {
     peek(state);
-    skip(state);
+    rbs_skip(state);
   }
 }
 

data/ext/rbs_extension/parser.c

@@ -37,6 +37,8 @@
   case kPUBLIC: \
   case kPRIVATE: \
   case kUNTYPED: \
+  case kUSE: \
+  case kAS: \
   /* nop */
 
 typedef struct {
@@ -1034,7 +1036,6 @@ VALUE parse_type(parserstate *state) {
 
   type_param ::= tUIDENT                            (module_type_params == false)
 */
-
 VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
   VALUE params = rb_ary_new();
 
@@ -1277,7 +1278,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,
@@ -1485,7 +1486,7 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
   range keyword_range;
   range name_range;
   range kind_range;
-  range overload_range = NULL_RANGE;
+  range overloading_range = NULL_RANGE;
 
   VALUE visibility;
 
@@ -1524,8 +1525,8 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
   }
 
   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(
@@ -1541,23 +1542,33 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
 
   bool loop = true;
   while (loop) {
+    VALUE annotations = rb_ary_new();
+    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(
@@ -1604,17 +1615,17 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
   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
   );
 }
@@ -2257,13 +2268,11 @@ 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) {
+VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_name, range name_range, VALUE comment, VALUE annotations) {
   range decl_range;
-  range keyword_range;
-  range name_range;
   range end_range;
   range type_params_range;
   range colon_range;
@@ -2271,15 +2280,8 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
 
   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;
+  decl_range.start = keyword_range.start;
 
-  parser_advance(state);
-  VALUE module_name = parse_type_name(state, CLASS_NAME, &name_range);
   VALUE type_params = parse_type_params(state, &type_params_range, true);
   VALUE self_types = rb_ary_new();
 
@@ -2322,6 +2324,46 @@ 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>
+
+*/
+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);
+  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;
+    decl_range.start = keyword_range.start;
+    decl_range.end = old_name_range.end;
+
+    VALUE location = rbs_new_location(state->buffer, decl_range);
+    rbs_loc *loc = rbs_check_location(location);
+    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>
                      | {<>}
@@ -2343,7 +2385,7 @@ VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
     args = rb_ary_new();
     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);
@@ -2358,35 +2400,25 @@ 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) {
+VALUE parse_class_decl0(parserstate *state, range keyword_range, VALUE name, range name_range, VALUE comment, 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;
 
   rbs_loc *loc;
 
   parser_push_typevar_table(state, true);
 
-  decl_range.start = state->current_token.range.start;
-  keyword_range = state->current_token.range;
-
-  comment_pos = nonnull_pos_or(comment_pos, decl_range.start);
-  comment = get_comment(state, comment_pos.line);
+  decl_range.start = keyword_range.start;
 
-  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);
@@ -2416,6 +2448,45 @@ VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotatio
   );
 }
 
+/*
+  class_decl ::= {`class`} class_name `=` <class_name>
+               | {`class`} class_name <class_decl0>
+*/
+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);
+  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;
+    decl_range.start = keyword_range.start;
+    decl_range.end = old_name_range.end;
+
+    VALUE location = rbs_new_location(state->buffer, decl_range);
+    rbs_loc *loc = rbs_check_location(location);
+    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>}
@@ -2491,18 +2562,185 @@ VALUE parse_decl(parserstate *state) {
   }
 }
 
+/*
+  namespace ::= {} (`::`)? (`tUIDENT` `::`)* `tUIDENT` <`::`>
+              | {} <>                                            (empty -- returns empty namespace)
+*/
+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;
+    is_absolute = true;
+
+    parser_advance(state);
+  }
+
+  VALUE path = rb_ary_new();
+
+  while (true) {
+    if (state->next_token.type == tUIDENT && state->next_token2.type == pCOLON2) {
+      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>
+*/
+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:
+      case tULIDENT:
+      case tUIDENT: {
+        parser_advance(state);
+
+        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;
+
+        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;
+        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_add_required_child(loc, rb_intern("type_name"), state->current_token.range);
+        if (!null_range_p(keyword_range)) {
+          rbs_loc_add_optional_child(loc, rb_intern("keyword"), keyword_range);
+        }
+        if (!null_range_p(new_name_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:
+      {
+        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_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>
+ */
+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_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 dirs = rb_ary_new();
   VALUE decls = rb_ary_new();
 
   while (state->next_token.type != pEOF) {
-    rb_ary_push(decls, parse_decl(state));
+    if (state->next_token.type == kUSE) {
+      VALUE use = parse_use_directive(state);
+      rb_ary_push(dirs, use);
+    } else  {
+      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;
 }
 
 static VALUE
-rbsparser_parse_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)
 {
   parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
 
@@ -2512,17 +2750,13 @@ rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, V
 
   VALUE type = parse_type(parser);
 
-  if (RTEST(requires_eof)) {
-    parser_advance_assert(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_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables)
 {
   parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
 
@@ -2532,10 +2766,6 @@ rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end
 
   VALUE method_type = parse_method_type(parser);
 
-  if (RTEST(requires_eof)) {
-    parser_advance_assert(parser, pEOF);
-  }
-
   free_parser(parser);
 
   return method_type;
@@ -2545,15 +2775,15 @@ 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);
+  VALUE pair = parse_signature(parser);
   free_parser(parser);
 
-  return signature;
+  return pair;
 }
 
 void rbs__init_parser(void) {
   RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
-  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_type", rbsparser_parse_type, 4);
+  rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 4);
   rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 2);
 }

data/ext/rbs_extension/ruby_objs.c

@@ -340,7 +340,7 @@ VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment)
   );
 }
 
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
+VALUE rbs_ast_decl_type_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
   rb_hash_aset(args, ID2SYM(rb_intern("type_params")), type_params);
@@ -350,7 +350,7 @@ VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annota
   rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
 
   return CLASS_NEW_INSTANCE(
-    RBS_AST_Declarations_Alias,
+    RBS_AST_Declarations_TypeAlias,
     1,
     &args
   );
@@ -402,15 +402,55 @@ VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE
   );
 }
 
-VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload, VALUE visibility) {
+VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("new_name")), new_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("old_name")), old_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_ClassAlias,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("new_name")), new_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("old_name")), old_name);
+  rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
+  rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Declarations_ModuleAlias,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_method_definition_overload(VALUE annotations, VALUE method_type) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
+  rb_hash_aset(args, ID2SYM(rb_intern("method_type")), method_type);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_AST_Members_MethodDefinition_Overload,
+    1,
+    &args
+  );
+}
+
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE overloads, VALUE annotations, VALUE location, VALUE comment, VALUE overloading, VALUE visibility) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
   rb_hash_aset(args, ID2SYM(rb_intern("kind")), kind);
-  rb_hash_aset(args, ID2SYM(rb_intern("types")), types);
+  rb_hash_aset(args, ID2SYM(rb_intern("overloads")), overloads);
   rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
   rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
-  rb_hash_aset(args, ID2SYM(rb_intern("overload")), overload);
+  rb_hash_aset(args, ID2SYM(rb_intern("overloading")), overloading);
   rb_hash_aset(args, ID2SYM(rb_intern("visibility")), visibility);
 
   return CLASS_NEW_INSTANCE(
@@ -523,3 +563,29 @@ VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE
     &kwargs
   );
 }
+
+VALUE rbs_ast_directives_use(VALUE clauses, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("clauses")), clauses);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(RBS_AST_Directives_Use, 1, &kwargs);
+}
+
+VALUE rbs_ast_directives_use_single_clause(VALUE type_name, VALUE new_name, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("type_name")), type_name);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("new_name")), new_name);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(RBS_AST_Directives_Use_SingleClause, 1, &kwargs);
+}
+
+VALUE rbs_ast_directives_use_wildcard_clause(VALUE namespace, VALUE location) {
+  VALUE kwargs = rb_hash_new();
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("namespace")), namespace);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+
+  return CLASS_NEW_INSTANCE(RBS_AST_Directives_Use_WildcardClause, 1, &kwargs);
+}
+