rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/ext/rbs_extension/ast_translation.c

@@ -11,6 +11,9 @@
 #include "rbs_string_bridging.h"
 #include "legacy_location.h"
 
+VALUE EMPTY_ARRAY;
+VALUE EMPTY_HASH;
+
 #define RBS_LOC_CHILDREN_SIZE(cap) (sizeof(rbs_loc_children) + sizeof(rbs_loc_entry) * ((cap) - 1))
 
 rbs_translation_context_t rbs_translation_context_create(rbs_constant_pool_t *constant_pool, VALUE buffer, rb_encoding *ruby_encoding) {
@@ -32,6 +35,10 @@ VALUE rbs_node_list_to_ruby_array(rbs_translation_context_t ctx, rbs_node_list_t
 }
 
 VALUE rbs_hash_to_ruby_hash(rbs_translation_context_t ctx, rbs_hash_t *rbs_hash) {
+    if (!rbs_hash->head) {
+        return EMPTY_HASH;
+    }
+
     VALUE ruby_hash = rb_hash_new();
 
     for (rbs_hash_node_t *n = rbs_hash->head; n != NULL; n = n->next) {
@@ -60,12 +67,12 @@ VALUE rbs_loc_to_ruby_location(rbs_translation_context_t ctx, rbs_location_t *so
 }
 
 VALUE rbs_location_list_to_ruby_array(rbs_translation_context_t ctx, rbs_location_list_t *list) {
-    VALUE ruby_array = rb_ary_new();
-
     if (list == NULL) {
-        return ruby_array;
+        return EMPTY_ARRAY;
     }
 
+    VALUE ruby_array = rb_ary_new();
+
     for (rbs_location_list_node_t *n = list->head; n != NULL; n = n->next) {
         rb_ary_push(ruby_array, rbs_loc_to_ruby_location(ctx, n->loc));
     }
@@ -573,6 +580,22 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_CLASS_ALIAS_ANNOTATION: {
+        rbs_ast_ruby_annotations_class_alias_annotation_t *node = (rbs_ast_ruby_annotations_class_alias_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_loc_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_loc_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("keyword_location")), rbs_loc_to_ruby_location(ctx, node->keyword_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("type_name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->type_name)); // rbs_type_name
+        rb_hash_aset(h, ID2SYM(rb_intern("type_name_location")), rbs_loc_to_ruby_location(ctx, node->type_name_location));
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_ClassAliasAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_RUBY_ANNOTATIONS_COLON_METHOD_TYPE_ANNOTATION: {
         rbs_ast_ruby_annotations_colon_method_type_annotation_t *node = (rbs_ast_ruby_annotations_colon_method_type_annotation_t *) instance;
 
@@ -588,6 +611,24 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_INSTANCE_VARIABLE_ANNOTATION: {
+        rbs_ast_ruby_annotations_instance_variable_annotation_t *node = (rbs_ast_ruby_annotations_instance_variable_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_loc_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_loc_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("ivar_name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->ivar_name)); // rbs_ast_symbol
+        rb_hash_aset(h, ID2SYM(rb_intern("ivar_name_location")), rbs_loc_to_ruby_location(ctx, node->ivar_name_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("colon_location")), rbs_loc_to_ruby_location(ctx, node->colon_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("type")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->type)); // rbs_node
+        rb_hash_aset(h, ID2SYM(rb_intern("comment_location")), rbs_loc_to_ruby_location(ctx, node->comment_location));
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_InstanceVariableAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_RUBY_ANNOTATIONS_METHOD_TYPES_ANNOTATION: {
         rbs_ast_ruby_annotations_method_types_annotation_t *node = (rbs_ast_ruby_annotations_method_types_annotation_t *) instance;
 
@@ -603,6 +644,22 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_MODULE_ALIAS_ANNOTATION: {
+        rbs_ast_ruby_annotations_module_alias_annotation_t *node = (rbs_ast_ruby_annotations_module_alias_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_loc_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_loc_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("keyword_location")), rbs_loc_to_ruby_location(ctx, node->keyword_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("type_name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->type_name)); // rbs_type_name
+        rb_hash_aset(h, ID2SYM(rb_intern("type_name_location")), rbs_loc_to_ruby_location(ctx, node->type_name_location));
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_ModuleAliasAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_RUBY_ANNOTATIONS_NODE_TYPE_ASSERTION: {
         rbs_ast_ruby_annotations_node_type_assertion_t *node = (rbs_ast_ruby_annotations_node_type_assertion_t *) instance;
 
@@ -649,6 +706,22 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_TYPE_APPLICATION_ANNOTATION: {
+        rbs_ast_ruby_annotations_type_application_annotation_t *node = (rbs_ast_ruby_annotations_type_application_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_loc_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_loc_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("type_args")), rbs_node_list_to_ruby_array(ctx, node->type_args));
+        rb_hash_aset(h, ID2SYM(rb_intern("close_bracket_location")), rbs_loc_to_ruby_location(ctx, node->close_bracket_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("comma_locations")), rbs_location_list_to_ruby_array(ctx, node->comma_locations));
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_TypeApplicationAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_STRING: {
         rbs_ast_string_t *string_node = (rbs_ast_string_t *) instance;
         rbs_string_t s = string_node->string;
@@ -663,6 +736,7 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
         rb_hash_aset(h, ID2SYM(rb_intern("name")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->name));                 // rbs_ast_symbol
         rb_hash_aset(h, ID2SYM(rb_intern("variance")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->variance));         // rbs_keyword
         rb_hash_aset(h, ID2SYM(rb_intern("upper_bound")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->upper_bound));   // rbs_node
+        rb_hash_aset(h, ID2SYM(rb_intern("lower_bound")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->lower_bound));   // rbs_node
         rb_hash_aset(h, ID2SYM(rb_intern("default_type")), rbs_struct_to_ruby_value(ctx, (rbs_node_t *) node->default_type)); // rbs_node
         rb_hash_aset(h, ID2SYM(rb_intern("unchecked")), node->unchecked ? Qtrue : Qfalse);
 

data/ext/rbs_extension/ast_translation.h

@@ -31,4 +31,7 @@ VALUE rbs_node_list_to_ruby_array(rbs_translation_context_t, rbs_node_list_t *li
 VALUE rbs_hash_to_ruby_hash(rbs_translation_context_t, rbs_hash_t *hash);
 VALUE rbs_struct_to_ruby_value(rbs_translation_context_t, rbs_node_t *instance);
 
+extern VALUE EMPTY_ARRAY;
+extern VALUE EMPTY_HASH;
+
 #endif

data/ext/rbs_extension/class_constants.c

@@ -7,8 +7,6 @@
 
 #include "rbs_extension.h"
 
-VALUE RBS_Parser;
-
 VALUE RBS;
 VALUE RBS_AST;
 VALUE RBS_AST_Declarations;
@@ -49,11 +47,15 @@ VALUE RBS_AST_Members_MethodDefinition_Overload;
 VALUE RBS_AST_Members_Prepend;
 VALUE RBS_AST_Members_Private;
 VALUE RBS_AST_Members_Public;
+VALUE RBS_AST_Ruby_Annotations_ClassAliasAnnotation;
 VALUE RBS_AST_Ruby_Annotations_ColonMethodTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
 VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 VALUE RBS_AST_TypeParam;
 VALUE RBS_MethodType;
 VALUE RBS_Namespace;
@@ -134,11 +136,15 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_AST_Members_Prepend, RBS_AST_Members, "Prepend");
     IMPORT_CONSTANT(RBS_AST_Members_Private, RBS_AST_Members, "Private");
     IMPORT_CONSTANT(RBS_AST_Members_Public, RBS_AST_Members, "Public");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ClassAliasAnnotation, RBS_AST_Ruby_Annotations, "ClassAliasAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ColonMethodTypeAnnotation, RBS_AST_Ruby_Annotations, "ColonMethodTypeAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_InstanceVariableAnnotation, RBS_AST_Ruby_Annotations, "InstanceVariableAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_MethodTypesAnnotation, RBS_AST_Ruby_Annotations, "MethodTypesAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ModuleAliasAnnotation, RBS_AST_Ruby_Annotations, "ModuleAliasAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_NodeTypeAssertion, RBS_AST_Ruby_Annotations, "NodeTypeAssertion");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ReturnTypeAnnotation, RBS_AST_Ruby_Annotations, "ReturnTypeAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_SkipAnnotation, RBS_AST_Ruby_Annotations, "SkipAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_TypeApplicationAnnotation, RBS_AST_Ruby_Annotations, "TypeApplicationAnnotation");
     IMPORT_CONSTANT(RBS_AST_TypeParam, RBS_AST, "TypeParam");
     IMPORT_CONSTANT(RBS_MethodType, RBS, "MethodType");
     IMPORT_CONSTANT(RBS_Namespace, RBS, "Namespace");

data/ext/rbs_extension/class_constants.h

@@ -55,11 +55,15 @@ extern VALUE RBS_AST_Members_MethodDefinition_Overload;
 extern VALUE RBS_AST_Members_Prepend;
 extern VALUE RBS_AST_Members_Private;
 extern VALUE RBS_AST_Members_Public;
+extern VALUE RBS_AST_Ruby_Annotations_ClassAliasAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_ColonMethodTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_InstanceVariableAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ModuleAliasAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 extern VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 extern VALUE RBS_AST_TypeParam;
 extern VALUE RBS_MethodType;
 extern VALUE RBS_Namespace;

data/ext/rbs_extension/extconf.rb

@@ -18,7 +18,11 @@ append_cflags [
   '-Wc++-compat',
 ]
 
-append_cflags ['-O0', '-g'] if ENV['DEBUG']
+if ENV['DEBUG']
+  append_cflags ['-O0', '-pg']
+else
+  append_cflags ['-DNDEBUG']
+end
 if ENV["TEST_NO_C23"]
   puts "Adding -Wc2x-extensions to CFLAGS"
   $CFLAGS << " -Werror -Wc2x-extensions"

data/ext/rbs_extension/legacy_location.c

@@ -33,7 +33,7 @@ void rbs_loc_legacy_alloc_children(rbs_loc *loc, unsigned short cap) {
     check_children_max(cap);
 
     size_t s = RBS_LOC_CHILDREN_SIZE(cap);
-    loc->children = malloc(s);
+    loc->children = (rbs_loc_children *) malloc(s);
 
     *loc->children = (rbs_loc_children) {
         .len = 0,
@@ -50,7 +50,7 @@ static void check_children_cap(rbs_loc *loc) {
         if (loc->children->len == loc->children->cap) {
             check_children_max(loc->children->cap + 1);
             size_t s = RBS_LOC_CHILDREN_SIZE(++loc->children->cap);
-            loc->children = realloc(loc->children, s);
+            loc->children = (rbs_loc_children *) realloc(loc->children, s);
         }
     }
 }
@@ -86,12 +86,12 @@ void rbs_loc_free(rbs_loc *loc) {
 }
 
 static void rbs_loc_mark(void *ptr) {
-    rbs_loc *loc = ptr;
+    rbs_loc *loc = (rbs_loc *) ptr;
     rb_gc_mark(loc->buffer);
 }
 
 static size_t rbs_loc_memsize(const void *ptr) {
-    const rbs_loc *loc = ptr;
+    const rbs_loc *loc = (const rbs_loc *) ptr;
     if (loc->children == NULL) {
         return sizeof(rbs_loc);
     } else {
@@ -117,7 +117,7 @@ static VALUE location_s_allocate(VALUE klass) {
 }
 
 rbs_loc *rbs_check_location(VALUE obj) {
-    return rb_check_typeddata(obj, &location_type);
+    return (rbs_loc *) rb_check_typeddata(obj, &location_type);
 }
 
 static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {

data/ext/rbs_extension/main.c

@@ -16,7 +16,7 @@
  * ```
  * */
 static NORETURN(void) raise_error(rbs_error_t *error, VALUE buffer) {
-    rbs_assert(error != NULL, "raise_error() called with NULL error");
+    RBS_ASSERT(error != NULL, "raise_error() called with NULL error");
 
     if (!error->syntax_error) {
         rb_raise(rb_eRuntimeError, "Unexpected error");
@@ -85,6 +85,22 @@ struct parse_type_arg {
     rb_encoding *encoding;
     rbs_parser_t *parser;
     VALUE require_eof;
+    VALUE void_allowed;
+    VALUE self_allowed;
+};
+
+struct parse_method_type_arg {
+    VALUE buffer;
+    rb_encoding *encoding;
+    rbs_parser_t *parser;
+    VALUE require_eof;
+};
+
+struct parse_signature_arg {
+    VALUE buffer;
+    rb_encoding *encoding;
+    rbs_parser_t *parser;
+    VALUE require_eof;
 };
 
 static VALUE ensure_free_parser(VALUE parser) {
@@ -100,8 +116,11 @@ static VALUE parse_type_try(VALUE a) {
         return Qnil;
     }
 
+    bool void_allowed = RTEST(arg->void_allowed);
+    bool self_allowed = RTEST(arg->self_allowed);
+
     rbs_node_t *type;
-    rbs_parse_type(parser, &type);
+    rbs_parse_type(parser, &type, void_allowed, self_allowed);
 
     raise_error_if_any(parser, arg->buffer);
 
@@ -157,7 +176,7 @@ static rbs_parser_t *alloc_parser_from_buffer(VALUE buffer, int start_pos, int e
     );
 }
 
-static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof) {
+static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof, VALUE void_allowed, VALUE self_allowed) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
@@ -168,7 +187,9 @@ static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VAL
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
-        .require_eof = require_eof
+        .require_eof = require_eof,
+        .void_allowed = void_allowed,
+        .self_allowed = self_allowed
     };
 
     VALUE result = rb_ensure(parse_type_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
@@ -179,7 +200,7 @@ static VALUE rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VAL
 }
 
 static VALUE parse_method_type_try(VALUE a) {
-    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    struct parse_method_type_arg *arg = (struct parse_method_type_arg *) a;
     rbs_parser_t *parser = arg->parser;
 
     if (parser->next_token.type == pEOF) {
@@ -187,18 +208,10 @@ static VALUE parse_method_type_try(VALUE a) {
     }
 
     rbs_method_type_t *method_type = NULL;
-    rbs_parse_method_type(parser, &method_type);
+    rbs_parse_method_type(parser, &method_type, RB_TEST(arg->require_eof));
 
     raise_error_if_any(parser, arg->buffer);
 
-    if (RB_TEST(arg->require_eof)) {
-        rbs_parser_advance(parser);
-        if (parser->current_token.type != pEOF) {
-            rbs_parser_set_error(parser, parser->current_token, true, "expected a token `%s`", rbs_token_type_str(pEOF));
-            raise_error(parser->error, arg->buffer);
-        }
-    }
-
     rbs_translation_context_t ctx = rbs_translation_context_create(
         &parser->constant_pool,
         arg->buffer,
@@ -215,7 +228,7 @@ static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_p
 
     rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
     declare_type_variables(parser, variables, buffer);
-    struct parse_type_arg arg = {
+    struct parse_method_type_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
@@ -230,7 +243,7 @@ static VALUE rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_p
 }
 
 static VALUE parse_signature_try(VALUE a) {
-    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    struct parse_signature_arg *arg = (struct parse_signature_arg *) a;
     rbs_parser_t *parser = arg->parser;
 
     rbs_signature_t *signature = NULL;
@@ -253,7 +266,7 @@ static VALUE rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE start_pos
     rb_encoding *encoding = rb_enc_get(string);
 
     rbs_parser_t *parser = alloc_parser_from_buffer(buffer, FIX2INT(start_pos), FIX2INT(end_pos));
-    struct parse_type_arg arg = {
+    struct parse_signature_arg arg = {
         .buffer = buffer,
         .encoding = encoding,
         .parser = parser,
@@ -429,10 +442,14 @@ static VALUE 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);
 
-    rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
+    EMPTY_ARRAY = rb_obj_freeze(rb_ary_new());
+    rb_gc_register_mark_object(EMPTY_ARRAY);
+
+    EMPTY_HASH = rb_obj_freeze(rb_hash_new());
+    rb_gc_register_mark_object(EMPTY_HASH);
+
+    rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 7);
     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, 3);
     rb_define_singleton_method(RBS_Parser, "_parse_type_params", rbsparser_parse_type_params, 4);

data/include/rbs/ast.h

@@ -45,43 +45,47 @@ enum rbs_node_type {
     RBS_AST_MEMBERS_PREPEND = 29,
     RBS_AST_MEMBERS_PRIVATE = 30,
     RBS_AST_MEMBERS_PUBLIC = 31,
-    RBS_AST_RUBY_ANNOTATIONS_COLON_METHOD_TYPE_ANNOTATION = 32,
-    RBS_AST_RUBY_ANNOTATIONS_METHOD_TYPES_ANNOTATION = 33,
-    RBS_AST_RUBY_ANNOTATIONS_NODE_TYPE_ASSERTION = 34,
-    RBS_AST_RUBY_ANNOTATIONS_RETURN_TYPE_ANNOTATION = 35,
-    RBS_AST_RUBY_ANNOTATIONS_SKIP_ANNOTATION = 36,
-    RBS_AST_STRING = 37,
-    RBS_AST_TYPE_PARAM = 38,
-    RBS_METHOD_TYPE = 39,
-    RBS_NAMESPACE = 40,
-    RBS_SIGNATURE = 41,
-    RBS_TYPE_NAME = 42,
-    RBS_TYPES_ALIAS = 43,
-    RBS_TYPES_BASES_ANY = 44,
-    RBS_TYPES_BASES_BOOL = 45,
-    RBS_TYPES_BASES_BOTTOM = 46,
-    RBS_TYPES_BASES_CLASS = 47,
-    RBS_TYPES_BASES_INSTANCE = 48,
-    RBS_TYPES_BASES_NIL = 49,
-    RBS_TYPES_BASES_SELF = 50,
-    RBS_TYPES_BASES_TOP = 51,
-    RBS_TYPES_BASES_VOID = 52,
-    RBS_TYPES_BLOCK = 53,
-    RBS_TYPES_CLASS_INSTANCE = 54,
-    RBS_TYPES_CLASS_SINGLETON = 55,
-    RBS_TYPES_FUNCTION = 56,
-    RBS_TYPES_FUNCTION_PARAM = 57,
-    RBS_TYPES_INTERFACE = 58,
-    RBS_TYPES_INTERSECTION = 59,
-    RBS_TYPES_LITERAL = 60,
-    RBS_TYPES_OPTIONAL = 61,
-    RBS_TYPES_PROC = 62,
-    RBS_TYPES_RECORD = 63,
-    RBS_TYPES_RECORD_FIELD_TYPE = 64,
-    RBS_TYPES_TUPLE = 65,
-    RBS_TYPES_UNION = 66,
-    RBS_TYPES_UNTYPED_FUNCTION = 67,
-    RBS_TYPES_VARIABLE = 68,
+    RBS_AST_RUBY_ANNOTATIONS_CLASS_ALIAS_ANNOTATION = 32,
+    RBS_AST_RUBY_ANNOTATIONS_COLON_METHOD_TYPE_ANNOTATION = 33,
+    RBS_AST_RUBY_ANNOTATIONS_INSTANCE_VARIABLE_ANNOTATION = 34,
+    RBS_AST_RUBY_ANNOTATIONS_METHOD_TYPES_ANNOTATION = 35,
+    RBS_AST_RUBY_ANNOTATIONS_MODULE_ALIAS_ANNOTATION = 36,
+    RBS_AST_RUBY_ANNOTATIONS_NODE_TYPE_ASSERTION = 37,
+    RBS_AST_RUBY_ANNOTATIONS_RETURN_TYPE_ANNOTATION = 38,
+    RBS_AST_RUBY_ANNOTATIONS_SKIP_ANNOTATION = 39,
+    RBS_AST_RUBY_ANNOTATIONS_TYPE_APPLICATION_ANNOTATION = 40,
+    RBS_AST_STRING = 41,
+    RBS_AST_TYPE_PARAM = 42,
+    RBS_METHOD_TYPE = 43,
+    RBS_NAMESPACE = 44,
+    RBS_SIGNATURE = 45,
+    RBS_TYPE_NAME = 46,
+    RBS_TYPES_ALIAS = 47,
+    RBS_TYPES_BASES_ANY = 48,
+    RBS_TYPES_BASES_BOOL = 49,
+    RBS_TYPES_BASES_BOTTOM = 50,
+    RBS_TYPES_BASES_CLASS = 51,
+    RBS_TYPES_BASES_INSTANCE = 52,
+    RBS_TYPES_BASES_NIL = 53,
+    RBS_TYPES_BASES_SELF = 54,
+    RBS_TYPES_BASES_TOP = 55,
+    RBS_TYPES_BASES_VOID = 56,
+    RBS_TYPES_BLOCK = 57,
+    RBS_TYPES_CLASS_INSTANCE = 58,
+    RBS_TYPES_CLASS_SINGLETON = 59,
+    RBS_TYPES_FUNCTION = 60,
+    RBS_TYPES_FUNCTION_PARAM = 61,
+    RBS_TYPES_INTERFACE = 62,
+    RBS_TYPES_INTERSECTION = 63,
+    RBS_TYPES_LITERAL = 64,
+    RBS_TYPES_OPTIONAL = 65,
+    RBS_TYPES_PROC = 66,
+    RBS_TYPES_RECORD = 67,
+    RBS_TYPES_RECORD_FIELD_TYPE = 68,
+    RBS_TYPES_TUPLE = 69,
+    RBS_TYPES_UNION = 70,
+    RBS_TYPES_UNTYPED_FUNCTION = 71,
+    RBS_TYPES_VARIABLE = 72,
     RBS_KEYWORD,
     RBS_AST_SYMBOL,
 };
@@ -397,6 +401,15 @@ typedef struct rbs_ast_members_public {
 
 } rbs_ast_members_public_t;
 
+typedef struct rbs_ast_ruby_annotations_class_alias_annotation {
+    rbs_node_t base;
+
+    struct rbs_location *prefix_location;
+    struct rbs_location *keyword_location;
+    struct rbs_type_name *type_name;
+    struct rbs_location *type_name_location;
+} rbs_ast_ruby_annotations_class_alias_annotation_t;
+
 typedef struct rbs_ast_ruby_annotations_colon_method_type_annotation {
     rbs_node_t base;
 
@@ -405,6 +418,17 @@ typedef struct rbs_ast_ruby_annotations_colon_method_type_annotation {
     struct rbs_node *method_type;
 } rbs_ast_ruby_annotations_colon_method_type_annotation_t;
 
+typedef struct rbs_ast_ruby_annotations_instance_variable_annotation {
+    rbs_node_t base;
+
+    struct rbs_location *prefix_location;
+    struct rbs_ast_symbol *ivar_name;
+    struct rbs_location *ivar_name_location;
+    struct rbs_location *colon_location;
+    struct rbs_node *type;
+    struct rbs_location *comment_location;
+} rbs_ast_ruby_annotations_instance_variable_annotation_t;
+
 typedef struct rbs_ast_ruby_annotations_method_types_annotation {
     rbs_node_t base;
 
@@ -413,6 +437,15 @@ typedef struct rbs_ast_ruby_annotations_method_types_annotation {
     struct rbs_location_list *vertical_bar_locations;
 } rbs_ast_ruby_annotations_method_types_annotation_t;
 
+typedef struct rbs_ast_ruby_annotations_module_alias_annotation {
+    rbs_node_t base;
+
+    struct rbs_location *prefix_location;
+    struct rbs_location *keyword_location;
+    struct rbs_type_name *type_name;
+    struct rbs_location *type_name_location;
+} rbs_ast_ruby_annotations_module_alias_annotation_t;
+
 typedef struct rbs_ast_ruby_annotations_node_type_assertion {
     rbs_node_t base;
 
@@ -438,6 +471,15 @@ typedef struct rbs_ast_ruby_annotations_skip_annotation {
     struct rbs_location *comment_location;
 } rbs_ast_ruby_annotations_skip_annotation_t;
 
+typedef struct rbs_ast_ruby_annotations_type_application_annotation {
+    rbs_node_t base;
+
+    struct rbs_location *prefix_location;
+    struct rbs_node_list *type_args;
+    struct rbs_location *close_bracket_location;
+    struct rbs_location_list *comma_locations;
+} rbs_ast_ruby_annotations_type_application_annotation_t;
+
 typedef struct rbs_ast_string {
     rbs_node_t base;
 
@@ -450,6 +492,7 @@ typedef struct rbs_ast_type_param {
     struct rbs_ast_symbol *name;
     struct rbs_keyword *variance;
     struct rbs_node *upper_bound;
+    struct rbs_node *lower_bound;
     struct rbs_node *default_type;
     bool unchecked;
 } rbs_ast_type_param_t;
@@ -706,13 +749,17 @@ rbs_ast_members_method_definition_overload_t *rbs_ast_members_method_definition_
 rbs_ast_members_prepend_t *rbs_ast_members_prepend_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_type_name_t *name, rbs_node_list_t *args, rbs_node_list_t *annotations, rbs_ast_comment_t *comment);
 rbs_ast_members_private_t *rbs_ast_members_private_new(rbs_allocator_t *allocator, rbs_location_t *location);
 rbs_ast_members_public_t *rbs_ast_members_public_new(rbs_allocator_t *allocator, rbs_location_t *location);
+rbs_ast_ruby_annotations_class_alias_annotation_t *rbs_ast_ruby_annotations_class_alias_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *keyword_location, rbs_type_name_t *type_name, rbs_location_t *type_name_location);
 rbs_ast_ruby_annotations_colon_method_type_annotation_t *rbs_ast_ruby_annotations_colon_method_type_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_list_t *annotations, rbs_node_t *method_type);
+rbs_ast_ruby_annotations_instance_variable_annotation_t *rbs_ast_ruby_annotations_instance_variable_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_ast_symbol_t *ivar_name, rbs_location_t *ivar_name_location, rbs_location_t *colon_location, rbs_node_t *type, rbs_location_t *comment_location);
 rbs_ast_ruby_annotations_method_types_annotation_t *rbs_ast_ruby_annotations_method_types_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_list_t *overloads, rbs_location_list_t *vertical_bar_locations);
+rbs_ast_ruby_annotations_module_alias_annotation_t *rbs_ast_ruby_annotations_module_alias_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *keyword_location, rbs_type_name_t *type_name, rbs_location_t *type_name_location);
 rbs_ast_ruby_annotations_node_type_assertion_t *rbs_ast_ruby_annotations_node_type_assertion_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_t *type);
 rbs_ast_ruby_annotations_return_type_annotation_t *rbs_ast_ruby_annotations_return_type_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *return_location, rbs_location_t *colon_location, rbs_node_t *return_type, rbs_location_t *comment_location);
 rbs_ast_ruby_annotations_skip_annotation_t *rbs_ast_ruby_annotations_skip_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *skip_location, rbs_location_t *comment_location);
+rbs_ast_ruby_annotations_type_application_annotation_t *rbs_ast_ruby_annotations_type_application_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_list_t *type_args, rbs_location_t *close_bracket_location, rbs_location_list_t *comma_locations);
 rbs_ast_string_t *rbs_ast_string_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_string_t string);
-rbs_ast_type_param_t *rbs_ast_type_param_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_ast_symbol_t *name, rbs_keyword_t *variance, rbs_node_t *upper_bound, rbs_node_t *default_type, bool unchecked);
+rbs_ast_type_param_t *rbs_ast_type_param_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_ast_symbol_t *name, rbs_keyword_t *variance, rbs_node_t *upper_bound, rbs_node_t *lower_bound, rbs_node_t *default_type, bool unchecked);
 rbs_method_type_t *rbs_method_type_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *type_params, rbs_node_t *type, rbs_types_block_t *block);
 rbs_namespace_t *rbs_namespace_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *path, bool absolute);
 rbs_signature_t *rbs_signature_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *directives, rbs_node_list_t *declarations);

data/include/rbs/defines.h

@@ -32,6 +32,24 @@
 #define RBS_ATTRIBUTE_FORMAT(string_index, argument_index)
 #endif
 
+/**
+ * Support RBS_LIKELY and RBS_UNLIKELY to help the compiler optimize its
+ * branch predication.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+/** The compiler should predicate that this branch will be taken. */
+#define RBS_LIKELY(x) __builtin_expect(!!(x), 1)
+
+/** The compiler should predicate that this branch will not be taken. */
+#define RBS_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+/** Void because this platform does not support branch prediction hints. */
+#define RBS_LIKELY(x) (x)
+
+/** Void because this platform does not support branch prediction hints. */
+#define RBS_UNLIKELY(x) (x)
+#endif
+
 /**
  * We use -Wimplicit-fallthrough to guard potentially unintended fall-through between cases of a switch.
  * Use RBS_FALLTHROUGH to explicitly annotate cases where the fallthrough is intentional.
@@ -56,4 +74,13 @@
 #define NODISCARD __attribute__((warn_unused_result))
 #endif
 
+/**
+ * Mark a function or variable as potentially unused to suppress compiler warnings.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#define RBS_ATTRIBUTE_UNUSED __attribute__((unused))
+#else
+#define RBS_ATTRIBUTE_UNUSED
+#endif
+
 #endif