rbs 3.10.4 → 4.0.0

data/ext/rbs_extension/class_constants.c

@@ -12,6 +12,8 @@ VALUE RBS_AST;
 VALUE RBS_AST_Declarations;
 VALUE RBS_AST_Directives;
 VALUE RBS_AST_Members;
+VALUE RBS_AST_Ruby;
+VALUE RBS_AST_Ruby_Annotations;
 VALUE RBS_Parser;
 VALUE RBS_Types;
 VALUE RBS_Types_Bases;
@@ -45,6 +47,19 @@ 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_BlockParamTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ClassAliasAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ColonMethodTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
+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_ParamTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+VALUE RBS_AST_Ruby_Annotations_SplatParamTypeAnnotation;
+VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 VALUE RBS_AST_TypeParam;
 VALUE RBS_MethodType;
 VALUE RBS_Namespace;
@@ -91,6 +106,8 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_AST_Declarations, RBS_AST, "Declarations");
     IMPORT_CONSTANT(RBS_AST_Directives, RBS_AST, "Directives");
     IMPORT_CONSTANT(RBS_AST_Members, RBS_AST, "Members");
+    IMPORT_CONSTANT(RBS_AST_Ruby, RBS_AST, "Ruby");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations, RBS_AST_Ruby, "Annotations");
     IMPORT_CONSTANT(RBS_Types, RBS, "Types");
     IMPORT_CONSTANT(RBS_Types_Bases, RBS_Types, "Bases");
 
@@ -123,6 +140,19 @@ 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_BlockParamTypeAnnotation, RBS_AST_Ruby_Annotations, "BlockParamTypeAnnotation");
+    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_DoubleSplatParamTypeAnnotation, RBS_AST_Ruby_Annotations, "DoubleSplatParamTypeAnnotation");
+    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_ParamTypeAnnotation, RBS_AST_Ruby_Annotations, "ParamTypeAnnotation");
+    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_SplatParamTypeAnnotation, RBS_AST_Ruby_Annotations, "SplatParamTypeAnnotation");
+    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

@@ -20,6 +20,8 @@ extern VALUE RBS_AST;
 extern VALUE RBS_AST_Declarations;
 extern VALUE RBS_AST_Directives;
 extern VALUE RBS_AST_Members;
+extern VALUE RBS_AST_Ruby;
+extern VALUE RBS_AST_Ruby_Annotations;
 extern VALUE RBS_Types;
 extern VALUE RBS_Types_Bases;
 extern VALUE RBS_ParsingError;
@@ -53,6 +55,19 @@ 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_BlockParamTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ClassAliasAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ColonMethodTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_DoubleSplatParamTypeAnnotation;
+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_ParamTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_SplatParamTypeAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 extern VALUE RBS_AST_TypeParam;
 extern VALUE RBS_MethodType;
 extern VALUE RBS_Namespace;

data/ext/rbs_extension/legacy_location.c

@@ -1,5 +1,6 @@
 #include "legacy_location.h"
 #include "rbs_extension.h"
+#include "ruby/internal/symbol.h"
 
 #define RBS_LOC_REQUIRED_P(loc, i) ((loc)->children->required_p & (1 << (i)))
 #define RBS_LOC_OPTIONAL_P(loc, i) (!RBS_LOC_REQUIRED_P((loc), (i)))
@@ -9,19 +10,6 @@
 rbs_loc_range RBS_LOC_NULL_RANGE = { -1, -1 };
 VALUE RBS_Location;
 
-rbs_position_t rbs_loc_position(int char_pos) {
-    return (rbs_position_t) { 0, char_pos, -1, -1 };
-}
-
-rbs_position_t rbs_loc_position3(int char_pos, int line, int column) {
-    return (rbs_position_t) { 0, char_pos, line, column };
-}
-
-static rbs_loc_range rbs_new_loc_range(rbs_range_t rg) {
-    rbs_loc_range r = { rg.start.char_pos, rg.end.char_pos };
-    return r;
-}
-
 static void check_children_max(unsigned short n) {
     size_t max = sizeof(rbs_loc_entry_bitmap) * 8;
     if (n > max) {
@@ -34,7 +22,6 @@ void rbs_loc_legacy_alloc_children(rbs_loc *loc, unsigned short cap) {
 
     size_t s = RBS_LOC_CHILDREN_SIZE(cap);
     loc->children = (rbs_loc_children *) malloc(s);
-
     *loc->children = (rbs_loc_children) {
         .len = 0,
         .required_p = 0,
@@ -55,17 +42,17 @@ static void check_children_cap(rbs_loc *loc) {
     }
 }
 
-void rbs_loc_legacy_add_optional_child(rbs_loc *loc, rbs_constant_id_t name, rbs_range_t r) {
+void rbs_loc_legacy_add_optional_child(rbs_loc *loc, ID name, rbs_loc_range r) {
     check_children_cap(loc);
 
     unsigned short i = loc->children->len++;
     loc->children->entries[i] = (rbs_loc_entry) {
         .name = name,
-        .rg = rbs_new_loc_range(r),
+        .rg = r,
     };
 }
 
-void rbs_loc_legacy_add_required_child(rbs_loc *loc, rbs_constant_id_t name, rbs_range_t r) {
+void rbs_loc_legacy_add_required_child(rbs_loc *loc, ID name, rbs_loc_range r) {
     rbs_loc_legacy_add_optional_child(loc, name, r);
 
     unsigned short last_index = loc->children->len - 1;
@@ -168,23 +155,15 @@ static VALUE location_end_pos(VALUE self) {
     return INT2FIX(loc->rg.end);
 }
 
-static rbs_constant_id_t rbs_constant_pool_insert_ruby_symbol(VALUE symbol) {
-    VALUE name = rb_sym2str(symbol);
-
-    // Constants inserted here will never be freed, but that's acceptable because:
-    // 1. Most symbols passed into here will be the ones already inserted into the constant pool by `parser.c`.
-    // 2. Methods like `add_required_child` and `add_optional_child` will usually only get called with a few different symbols.
-    return rbs_constant_pool_insert_constant(RBS_GLOBAL_CONSTANT_POOL, (const uint8_t *) RSTRING_PTR(name), RSTRING_LEN(name));
-}
-
 static VALUE location_add_required_child(VALUE self, VALUE name, VALUE start, VALUE end) {
     rbs_loc *loc = rbs_check_location(self);
 
-    rbs_range_t rg;
-    rg.start = rbs_loc_position(FIX2INT(start));
-    rg.end = rbs_loc_position(FIX2INT(end));
+    rbs_loc_range rg = {
+        .start = FIX2INT(start),
+        .end = FIX2INT(end),
+    };
 
-    rbs_loc_legacy_add_required_child(loc, rbs_constant_pool_insert_ruby_symbol(name), rg);
+    rbs_loc_legacy_add_required_child(loc, rb_sym2id(name), rg);
 
     return Qnil;
 }
@@ -192,11 +171,12 @@ static VALUE location_add_required_child(VALUE self, VALUE name, VALUE start, VA
 static VALUE location_add_optional_child(VALUE self, VALUE name, VALUE start, VALUE end) {
     rbs_loc *loc = rbs_check_location(self);
 
-    rbs_range_t rg;
-    rg.start = rbs_loc_position(FIX2INT(start));
-    rg.end = rbs_loc_position(FIX2INT(end));
+    rbs_loc_range rg = {
+        .start = FIX2INT(start),
+        .end = FIX2INT(end),
+    };
 
-    rbs_loc_legacy_add_optional_child(loc, rbs_constant_pool_insert_ruby_symbol(name), rg);
+    rbs_loc_legacy_add_optional_child(loc, rb_sym2id(name), rg);
 
     return Qnil;
 }
@@ -204,7 +184,7 @@ static VALUE location_add_optional_child(VALUE self, VALUE name, VALUE start, VA
 static VALUE location_add_optional_no_child(VALUE self, VALUE name) {
     rbs_loc *loc = rbs_check_location(self);
 
-    rbs_loc_legacy_add_optional_child(loc, rbs_constant_pool_insert_ruby_symbol(name), NULL_RANGE);
+    rbs_loc_legacy_add_optional_child(loc, rb_sym2id(name), RBS_LOC_NULL_RANGE);
 
     return Qnil;
 }
@@ -213,32 +193,35 @@ VALUE rbs_new_location(VALUE buffer, rbs_range_t rg) {
     rbs_loc *loc;
     VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    rbs_loc_init(loc, buffer, rbs_new_loc_range(rg));
+    rbs_loc_init(loc, buffer, (rbs_loc_range) { rg.start.char_pos, rg.end.char_pos });
 
     return obj;
 }
 
-static VALUE rbs_new_location_from_loc_range(VALUE buffer, rbs_loc_range rg) {
+VALUE rbs_new_location2(VALUE buffer, int start_char, int end_char) {
     rbs_loc *loc;
     VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    rbs_loc_init(loc, buffer, rg);
+    rbs_loc_init(loc, buffer, (rbs_loc_range) { .start = start_char, .end = end_char });
 
     return obj;
 }
 
-static rbs_constant_id_t rbs_constant_pool_find_ruby_symbol(VALUE symbol) {
-    VALUE name = rb_sym2str(symbol);
+static VALUE rbs_new_location_from_loc_range(VALUE buffer, rbs_loc_range rg) {
+    rbs_loc *loc;
+    VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
 
-    return rbs_constant_pool_find(RBS_GLOBAL_CONSTANT_POOL, (const uint8_t *) RSTRING_PTR(name), RSTRING_LEN(name));
+    rbs_loc_init(loc, buffer, rg);
+
+    return obj;
 }
 
 static VALUE location_aref(VALUE self, VALUE name) {
     rbs_loc *loc = rbs_check_location(self);
 
-    rbs_constant_id_t id = rbs_constant_pool_find_ruby_symbol(name);
+    ID id = rb_sym2id(name);
 
-    if (loc->children != NULL && id != RBS_CONSTANT_ID_UNSET) {
+    if (loc->children != NULL) {
         for (unsigned short i = 0; i < loc->children->len; i++) {
             if (loc->children->entries[i].name == id) {
                 rbs_loc_range result = loc->children->entries[i].rg;
@@ -256,10 +239,6 @@ static VALUE location_aref(VALUE self, VALUE name) {
     rb_raise(rb_eRuntimeError, "Unknown child name given: %s", RSTRING_PTR(string));
 }
 
-static VALUE rbs_constant_to_ruby_symbol(rbs_constant_t *constant) {
-    return ID2SYM(rb_intern2((const char *) constant->start, constant->length));
-}
-
 static VALUE location_optional_keys(VALUE self) {
     VALUE keys = rb_ary_new();
 
@@ -271,8 +250,7 @@ static VALUE location_optional_keys(VALUE self) {
 
     for (unsigned short i = 0; i < children->len; i++) {
         if (RBS_LOC_OPTIONAL_P(loc, i)) {
-            rbs_constant_t *key_id = rbs_constant_pool_id_to_constant(RBS_GLOBAL_CONSTANT_POOL, children->entries[i].name);
-            VALUE key_sym = rbs_constant_to_ruby_symbol(key_id);
+            VALUE key_sym = rb_id2sym(children->entries[i].name);
             rb_ary_push(keys, key_sym);
         }
     }
@@ -291,8 +269,7 @@ static VALUE location_required_keys(VALUE self) {
 
     for (unsigned short i = 0; i < children->len; i++) {
         if (RBS_LOC_REQUIRED_P(loc, i)) {
-            rbs_constant_t *key_id = rbs_constant_pool_id_to_constant(RBS_GLOBAL_CONSTANT_POOL, children->entries[i].name);
-            VALUE key_sym = rbs_constant_to_ruby_symbol(key_id);
+            VALUE key_sym = rb_id2sym(children->entries[i].name);
             rb_ary_push(keys, key_sym);
         }
     }
@@ -306,8 +283,8 @@ void rbs__init_location(void) {
     rb_define_private_method(RBS_Location, "initialize", location_initialize, 3);
     rb_define_private_method(RBS_Location, "initialize_copy", location_initialize_copy, 1);
     rb_define_method(RBS_Location, "buffer", location_buffer, 0);
-    rb_define_method(RBS_Location, "start_pos", location_start_pos, 0);
-    rb_define_method(RBS_Location, "end_pos", location_end_pos, 0);
+    rb_define_method(RBS_Location, "_start_pos", location_start_pos, 0);
+    rb_define_method(RBS_Location, "_end_pos", location_end_pos, 0);
     rb_define_method(RBS_Location, "_add_required_child", location_add_required_child, 3);
     rb_define_method(RBS_Location, "_add_optional_child", location_add_optional_child, 3);
     rb_define_method(RBS_Location, "_add_optional_no_child", location_add_optional_no_child, 1);

data/ext/rbs_extension/legacy_location.h

@@ -9,11 +9,43 @@ SUPPRESS_RUBY_HEADER_DIAGNOSTICS_END
 
 #include "rbs.h"
 
+/**
+ * Data structures for implementing RBS::Location class in Ruby.
+ *
+ * These structs support hierarchical locations, allowing sub-locations (children)
+ * to be stored under a main location. Each sub-location is identified by its
+ * name (Ruby Symbol ID).
+ */
+
 /**
  * RBS::Location class
  * */
 extern VALUE RBS_Location;
 
+/**
+ * Range of character index for `rbs_loc` locations.
+ */
+typedef struct {
+    int start;
+    int end;
+} rbs_loc_range;
+
+typedef struct {
+    ID name; /* Ruby ID for the name of the entry */
+    rbs_loc_range rg;
+} rbs_loc_entry;
+
+typedef unsigned int rbs_loc_entry_bitmap;
+
+// The flexible array always allocates, but it's okay.
+// This struct is not allocated when the `rbs_loc` doesn't have children.
+typedef struct {
+    unsigned short len;
+    unsigned short cap;
+    rbs_loc_entry_bitmap required_p;
+    rbs_loc_entry entries[1];
+} rbs_loc_children;
+
 typedef struct {
     VALUE buffer;
     rbs_loc_range rg;
@@ -25,6 +57,8 @@ typedef struct {
  * */
 VALUE rbs_new_location(VALUE buffer, rbs_range_t rg);
 
+VALUE rbs_new_location2(VALUE buffer, int start_char, int end_char);
+
 /**
  * Return rbs_loc associated with the RBS::Location object.
  * */
@@ -37,6 +71,9 @@ rbs_loc *rbs_check_location(VALUE location);
  * */
 void rbs_loc_legacy_alloc_children(rbs_loc *loc, unsigned short cap);
 
+void rbs_loc_legacy_add_optional_child(rbs_loc *loc, ID name, rbs_loc_range r);
+void rbs_loc_legacy_add_required_child(rbs_loc *loc, ID name, rbs_loc_range r);
+
 /**
  * Define RBS::Location class.
  * */

data/ext/rbs_extension/main.c

@@ -67,10 +67,12 @@ static void declare_type_variables(rbs_parser_t *parser, VALUE variables, VALUE
         }
 
         VALUE name_str = rb_sym2str(symbol);
+        uint8_t *copied_name = (uint8_t *) malloc((size_t) RSTRING_LEN(name_str));
+        memcpy((void *) copied_name, RSTRING_PTR(name_str), RSTRING_LEN(name_str));
 
-        rbs_constant_id_t id = rbs_constant_pool_insert_shared(
+        rbs_constant_id_t id = rbs_constant_pool_insert_owned(
             &parser->constant_pool,
-            (const uint8_t *) RSTRING_PTR(name_str),
+            copied_name,
             RSTRING_LEN(name_str)
         );
 
@@ -85,6 +87,23 @@ struct parse_type_arg {
     rb_encoding *encoding;
     rbs_parser_t *parser;
     VALUE require_eof;
+    VALUE void_allowed;
+    VALUE self_allowed;
+    VALUE classish_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 +119,12 @@ static VALUE parse_type_try(VALUE a) {
         return Qnil;
     }
 
+    bool void_allowed = RTEST(arg->void_allowed);
+    bool self_allowed = RTEST(arg->self_allowed);
+    bool classish_allowed = RTEST(arg->classish_allowed);
+
     rbs_node_t *type;
-    rbs_parse_type(parser, &type);
+    rbs_parse_type(parser, &type, void_allowed, self_allowed, classish_allowed);
 
     raise_error_if_any(parser, arg->buffer);
 
@@ -157,7 +180,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 classish_allowed) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
     rb_encoding *encoding = rb_enc_get(string);
@@ -168,7 +191,10 @@ 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,
+        .classish_allowed = classish_allowed
     };
 
     VALUE result = rb_ensure(parse_type_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
@@ -179,7 +205,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,7 +213,7 @@ static VALUE parse_method_type_try(VALUE a) {
     }
 
     rbs_method_type_t *method_type = NULL;
-    rbs_parse_method_type(parser, &method_type, RB_TEST(arg->require_eof));
+    rbs_parse_method_type(parser, &method_type, RB_TEST(arg->require_eof), true);
 
     raise_error_if_any(parser, arg->buffer);
 
@@ -207,7 +233,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,
@@ -222,7 +248,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;
@@ -245,7 +271,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,
@@ -308,6 +334,92 @@ static VALUE rbsparser_parse_type_params(VALUE self, VALUE buffer, VALUE start_p
     return result;
 }
 
+static VALUE parse_inline_leading_annotation_try(VALUE a) {
+    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    rbs_parser_t *parser = arg->parser;
+
+    rbs_ast_ruby_annotations_t *annotation = NULL;
+    bool success = rbs_parse_inline_leading_annotation(parser, &annotation);
+
+    raise_error_if_any(parser, arg->buffer);
+
+    if (!success || annotation == NULL) {
+        return Qnil;
+    }
+
+    rbs_translation_context_t ctx = rbs_translation_context_create(
+        &parser->constant_pool,
+        arg->buffer,
+        arg->encoding
+    );
+
+    return rbs_struct_to_ruby_value(ctx, (rbs_node_t *) annotation);
+}
+
+static VALUE rbsparser_parse_inline_leading_annotation(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables) {
+    VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+    StringValue(string);
+    rb_encoding *encoding = rb_enc_get(string);
+
+    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 = {
+        .buffer = buffer,
+        .encoding = encoding,
+        .parser = parser,
+        .require_eof = Qfalse
+    };
+
+    VALUE result = rb_ensure(parse_inline_leading_annotation_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
+
+    RB_GC_GUARD(string);
+
+    return result;
+}
+
+static VALUE parse_inline_trailing_annotation_try(VALUE a) {
+    struct parse_type_arg *arg = (struct parse_type_arg *) a;
+    rbs_parser_t *parser = arg->parser;
+
+    rbs_ast_ruby_annotations_t *annotation = NULL;
+    bool success = rbs_parse_inline_trailing_annotation(parser, &annotation);
+
+    raise_error_if_any(parser, arg->buffer);
+
+    if (!success || annotation == NULL) {
+        return Qnil;
+    }
+
+    rbs_translation_context_t ctx = rbs_translation_context_create(
+        &parser->constant_pool,
+        arg->buffer,
+        arg->encoding
+    );
+
+    return rbs_struct_to_ruby_value(ctx, (rbs_node_t *) annotation);
+}
+
+static VALUE rbsparser_parse_inline_trailing_annotation(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables) {
+    VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+    StringValue(string);
+    rb_encoding *encoding = rb_enc_get(string);
+
+    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 = {
+        .buffer = buffer,
+        .encoding = encoding,
+        .parser = parser,
+        .require_eof = Qfalse
+    };
+
+    VALUE result = rb_ensure(parse_inline_trailing_annotation_try, (VALUE) &arg, ensure_free_parser, (VALUE) parser);
+
+    RB_GC_GUARD(string);
+
+    return result;
+}
+
 static VALUE rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
     VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
     StringValue(string);
@@ -342,15 +454,16 @@ void rbs__init_parser(void) {
     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, 5);
+    rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 8);
     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);
+    rb_define_singleton_method(RBS_Parser, "_parse_inline_leading_annotation", rbsparser_parse_inline_leading_annotation, 4);
+    rb_define_singleton_method(RBS_Parser, "_parse_inline_trailing_annotation", rbsparser_parse_inline_trailing_annotation, 4);
     rb_define_singleton_method(RBS_Parser, "_lex", rbsparser_lex, 2);
 }
 
 static void Deinit_rbs_extension(ruby_vm_t *_) {
-    rbs_constant_pool_free(RBS_GLOBAL_CONSTANT_POOL);
 }
 
 void Init_rbs_extension(void) {
@@ -361,17 +474,5 @@ void Init_rbs_extension(void) {
     rbs__init_location();
     rbs__init_parser();
 
-    /* Calculated based on the number of unique strings used with the `INTERN` macro in `parser.c`.
-   *
-   * ```bash
-   * grep -o 'INTERN("\([^"]*\)")' ext/rbs_extension/parser.c \
-   *     | sed 's/INTERN("\(.*\)")/\1/' \
-   *     | sort -u \
-   *     | wc -l
-   * ```
-   */
-    const size_t num_uniquely_interned_strings = 26;
-    rbs_constant_pool_init(RBS_GLOBAL_CONSTANT_POOL, num_uniquely_interned_strings);
-
     ruby_vm_at_exit(Deinit_rbs_extension);
 }