rbs 3.0.0.dev.1 → 3.0.0.dev.3

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,
@@ -2267,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;
@@ -2281,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();
 
@@ -2332,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>
                      | {<>}
@@ -2368,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);
@@ -2426,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>}
@@ -2501,18 +2562,184 @@ 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 == kUSE) {
+    rb_ary_push(dirs, parse_use_directive(state));
+  }
+
   while (state->next_token.type != pEOF) {
     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);
 
@@ -2522,17 +2749,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);
 
@@ -2542,10 +2765,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;
@@ -2555,15 +2774,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,6 +402,34 @@ VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE
   );
 }
 
+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);
@@ -535,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);
+}
+

data/ext/rbs_extension/ruby_objs.h

@@ -7,7 +7,7 @@ VALUE rbs_alias(VALUE typename, VALUE args, VALUE location);
 VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, VALUE location);
 VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE location);
-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 rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
@@ -15,6 +15,8 @@ VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment)
 VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
 VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
 VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE overloads, VALUE annotations, VALUE location, VALUE comment, VALUE overloading, VALUE visibility);
@@ -41,4 +43,8 @@ VALUE rbs_type_name(VALUE namespace, VALUE name);
 VALUE rbs_union(VALUE types, VALUE location);
 VALUE rbs_variable(VALUE name, VALUE location);
 
+VALUE rbs_ast_directives_use(VALUE clauses, VALUE location);
+VALUE rbs_ast_directives_use_single_clause(VALUE type_name, VALUE new_name, VALUE location);
+VALUE rbs_ast_directives_use_wildcard_clause(VALUE namespace, VALUE location);
+
 #endif

data/lib/rbs/annotate/rdoc_annotator.rb

@@ -16,7 +16,7 @@ module RBS
       def annotate_file(path, preserve:)
         content = path.read()
 
-        decls = Parser.parse_signature(content)
+        _, _, decls = Parser.parse_signature(content)
 
         annotate_decls(decls)
 

data/lib/rbs/ast/declarations.rb

@@ -265,7 +265,7 @@ module RBS
         end
       end
 
-      class Alias < Base
+      class TypeAlias < Base
         attr_reader :name
         attr_reader :type_params
         attr_reader :type
@@ -283,7 +283,7 @@ module RBS
         end
 
         def ==(other)
-          other.is_a?(Alias) &&
+          other.is_a?(TypeAlias) &&
             other.name == name &&
             other.type_params == type_params &&
             other.type == type
@@ -379,6 +379,53 @@ module RBS
           }.to_json(state)
         end
       end
+
+      class AliasDecl < Base
+        attr_reader :new_name, :old_name, :location, :comment
+
+        def initialize(new_name:, old_name:, location:, comment:)
+          @new_name = new_name
+          @old_name = old_name
+          @location = location
+          @comment = comment
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.new_name == new_name &&
+            other.old_name == old_name
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ new_name.hash ^ old_name.hash
+        end
+      end
+
+      class ClassAlias < AliasDecl
+        def to_json(state = _ = nil)
+          {
+            declaration: :class_alias,
+            new_name: new_name,
+            old_name: old_name,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class ModuleAlias < AliasDecl
+        def to_json(state = _ = nil)
+          {
+            declaration: :module_alias,
+            new_name: new_name,
+            old_name: old_name,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
     end
   end
 end