rbs 3.9.5 → 4.0.0

data/ext/rbs_extension/ast_translation.h

@@ -0,0 +1,37 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually.                                                      */
+/* To change the template see                                                 */
+/* templates/ext/rbs_extension/ast_translation.h.erb                          */
+/*----------------------------------------------------------------------------*/
+
+#ifndef RBS_EXTENSION_AST_TRANSLATION_H
+#define RBS_EXTENSION_AST_TRANSLATION_H
+
+#include "compat.h"
+
+SUPPRESS_RUBY_HEADER_DIAGNOSTICS_BEGIN
+#include "ruby.h"
+#include "ruby/encoding.h"
+SUPPRESS_RUBY_HEADER_DIAGNOSTICS_END
+
+#include "rbs/ast.h"
+#include "rbs/location.h"
+
+/// A bag of values needed when copying RBS C structs into Ruby objects.
+typedef struct rbs_translation_context {
+    rbs_constant_pool_t *constant_pool;
+    VALUE buffer;
+    rb_encoding *encoding;
+} rbs_translation_context_t;
+
+rbs_translation_context_t rbs_translation_context_create(rbs_constant_pool_t *, VALUE buffer_string, rb_encoding *ruby_encoding);
+
+VALUE rbs_node_list_to_ruby_array(rbs_translation_context_t, rbs_node_list_t *list);
+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

@@ -0,0 +1,185 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually.                                                      */
+/* To change the template see                                                 */
+/* templates/ext/rbs_extension/class_constants.c.erb                          */
+/*----------------------------------------------------------------------------*/
+
+#include "rbs_extension.h"
+
+VALUE RBS;
+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;
+
+VALUE RBS_AST_Annotation;
+VALUE RBS_AST_Comment;
+VALUE RBS_AST_Declarations_Class;
+VALUE RBS_AST_Declarations_Class_Super;
+VALUE RBS_AST_Declarations_ClassAlias;
+VALUE RBS_AST_Declarations_Constant;
+VALUE RBS_AST_Declarations_Global;
+VALUE RBS_AST_Declarations_Interface;
+VALUE RBS_AST_Declarations_Module;
+VALUE RBS_AST_Declarations_Module_Self;
+VALUE RBS_AST_Declarations_ModuleAlias;
+VALUE RBS_AST_Declarations_TypeAlias;
+VALUE RBS_AST_Directives_Use;
+VALUE RBS_AST_Directives_Use_SingleClause;
+VALUE RBS_AST_Directives_Use_WildcardClause;
+VALUE RBS_AST_Members_Alias;
+VALUE RBS_AST_Members_AttrAccessor;
+VALUE RBS_AST_Members_AttrReader;
+VALUE RBS_AST_Members_AttrWriter;
+VALUE RBS_AST_Members_ClassInstanceVariable;
+VALUE RBS_AST_Members_ClassVariable;
+VALUE RBS_AST_Members_Extend;
+VALUE RBS_AST_Members_Include;
+VALUE RBS_AST_Members_InstanceVariable;
+VALUE RBS_AST_Members_MethodDefinition;
+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;
+VALUE RBS_TypeName;
+VALUE RBS_Types_Alias;
+VALUE RBS_Types_Bases_Any;
+VALUE RBS_Types_Bases_Bool;
+VALUE RBS_Types_Bases_Bottom;
+VALUE RBS_Types_Bases_Class;
+VALUE RBS_Types_Bases_Instance;
+VALUE RBS_Types_Bases_Nil;
+VALUE RBS_Types_Bases_Self;
+VALUE RBS_Types_Bases_Top;
+VALUE RBS_Types_Bases_Void;
+VALUE RBS_Types_Block;
+VALUE RBS_Types_ClassInstance;
+VALUE RBS_Types_ClassSingleton;
+VALUE RBS_Types_Function;
+VALUE RBS_Types_Function_Param;
+VALUE RBS_Types_Interface;
+VALUE RBS_Types_Intersection;
+VALUE RBS_Types_Literal;
+VALUE RBS_Types_Optional;
+VALUE RBS_Types_Proc;
+VALUE RBS_Types_Record;
+VALUE RBS_Types_Tuple;
+VALUE RBS_Types_Union;
+VALUE RBS_Types_UntypedFunction;
+VALUE RBS_Types_Variable;
+
+VALUE RBS_ParsingError;
+
+#define IMPORT_CONSTANT(var, parent, name)           \
+    {                                                \
+        var = rb_const_get(parent, rb_intern(name)); \
+        rb_gc_register_mark_object(var);             \
+    }
+
+void rbs__init_constants(void) {
+    IMPORT_CONSTANT(RBS, rb_cObject, "RBS");
+    IMPORT_CONSTANT(RBS_ParsingError, RBS, "ParsingError");
+
+    IMPORT_CONSTANT(RBS_AST, RBS, "AST");
+    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");
+
+    IMPORT_CONSTANT(RBS_AST_Annotation, RBS_AST, "Annotation");
+    IMPORT_CONSTANT(RBS_AST_Comment, RBS_AST, "Comment");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Class, RBS_AST_Declarations, "Class");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Class_Super, RBS_AST_Declarations_Class, "Super");
+    IMPORT_CONSTANT(RBS_AST_Declarations_ClassAlias, RBS_AST_Declarations, "ClassAlias");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Constant, RBS_AST_Declarations, "Constant");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Global, RBS_AST_Declarations, "Global");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Interface, RBS_AST_Declarations, "Interface");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Module, RBS_AST_Declarations, "Module");
+    IMPORT_CONSTANT(RBS_AST_Declarations_Module_Self, RBS_AST_Declarations_Module, "Self");
+    IMPORT_CONSTANT(RBS_AST_Declarations_ModuleAlias, RBS_AST_Declarations, "ModuleAlias");
+    IMPORT_CONSTANT(RBS_AST_Declarations_TypeAlias, RBS_AST_Declarations, "TypeAlias");
+    IMPORT_CONSTANT(RBS_AST_Directives_Use, RBS_AST_Directives, "Use");
+    IMPORT_CONSTANT(RBS_AST_Directives_Use_SingleClause, RBS_AST_Directives_Use, "SingleClause");
+    IMPORT_CONSTANT(RBS_AST_Directives_Use_WildcardClause, RBS_AST_Directives_Use, "WildcardClause");
+    IMPORT_CONSTANT(RBS_AST_Members_Alias, RBS_AST_Members, "Alias");
+    IMPORT_CONSTANT(RBS_AST_Members_AttrAccessor, RBS_AST_Members, "AttrAccessor");
+    IMPORT_CONSTANT(RBS_AST_Members_AttrReader, RBS_AST_Members, "AttrReader");
+    IMPORT_CONSTANT(RBS_AST_Members_AttrWriter, RBS_AST_Members, "AttrWriter");
+    IMPORT_CONSTANT(RBS_AST_Members_ClassInstanceVariable, RBS_AST_Members, "ClassInstanceVariable");
+    IMPORT_CONSTANT(RBS_AST_Members_ClassVariable, RBS_AST_Members, "ClassVariable");
+    IMPORT_CONSTANT(RBS_AST_Members_Extend, RBS_AST_Members, "Extend");
+    IMPORT_CONSTANT(RBS_AST_Members_Include, RBS_AST_Members, "Include");
+    IMPORT_CONSTANT(RBS_AST_Members_InstanceVariable, RBS_AST_Members, "InstanceVariable");
+    IMPORT_CONSTANT(RBS_AST_Members_MethodDefinition, RBS_AST_Members, "MethodDefinition");
+    IMPORT_CONSTANT(RBS_AST_Members_MethodDefinition_Overload, RBS_AST_Members_MethodDefinition, "Overload");
+    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");
+    IMPORT_CONSTANT(RBS_TypeName, RBS, "TypeName");
+    IMPORT_CONSTANT(RBS_Types_Alias, RBS_Types, "Alias");
+    IMPORT_CONSTANT(RBS_Types_Bases_Any, RBS_Types_Bases, "Any");
+    IMPORT_CONSTANT(RBS_Types_Bases_Bool, RBS_Types_Bases, "Bool");
+    IMPORT_CONSTANT(RBS_Types_Bases_Bottom, RBS_Types_Bases, "Bottom");
+    IMPORT_CONSTANT(RBS_Types_Bases_Class, RBS_Types_Bases, "Class");
+    IMPORT_CONSTANT(RBS_Types_Bases_Instance, RBS_Types_Bases, "Instance");
+    IMPORT_CONSTANT(RBS_Types_Bases_Nil, RBS_Types_Bases, "Nil");
+    IMPORT_CONSTANT(RBS_Types_Bases_Self, RBS_Types_Bases, "Self");
+    IMPORT_CONSTANT(RBS_Types_Bases_Top, RBS_Types_Bases, "Top");
+    IMPORT_CONSTANT(RBS_Types_Bases_Void, RBS_Types_Bases, "Void");
+    IMPORT_CONSTANT(RBS_Types_Block, RBS_Types, "Block");
+    IMPORT_CONSTANT(RBS_Types_ClassInstance, RBS_Types, "ClassInstance");
+    IMPORT_CONSTANT(RBS_Types_ClassSingleton, RBS_Types, "ClassSingleton");
+    IMPORT_CONSTANT(RBS_Types_Function, RBS_Types, "Function");
+    IMPORT_CONSTANT(RBS_Types_Function_Param, RBS_Types_Function, "Param");
+    IMPORT_CONSTANT(RBS_Types_Interface, RBS_Types, "Interface");
+    IMPORT_CONSTANT(RBS_Types_Intersection, RBS_Types, "Intersection");
+    IMPORT_CONSTANT(RBS_Types_Literal, RBS_Types, "Literal");
+    IMPORT_CONSTANT(RBS_Types_Optional, RBS_Types, "Optional");
+    IMPORT_CONSTANT(RBS_Types_Proc, RBS_Types, "Proc");
+    IMPORT_CONSTANT(RBS_Types_Record, RBS_Types, "Record");
+    IMPORT_CONSTANT(RBS_Types_Tuple, RBS_Types, "Tuple");
+    IMPORT_CONSTANT(RBS_Types_Union, RBS_Types, "Union");
+    IMPORT_CONSTANT(RBS_Types_UntypedFunction, RBS_Types, "UntypedFunction");
+    IMPORT_CONSTANT(RBS_Types_Variable, RBS_Types, "Variable");
+}

data/{include/rbs/constants.h → ext/rbs_extension/class_constants.h}

@@ -2,18 +2,26 @@
 /* This file is generated by the templates/template.rb script and should not  */
 /* be modified manually.                                                      */
 /* To change the template see                                                 */
-/* templates/include/rbs/constants.h.erb                                      */
+/* templates/ext/rbs_extension/class_constants.h.erb                          */
 /*----------------------------------------------------------------------------*/
 
 #ifndef RBS__CONSTANTS_H
 #define RBS__CONSTANTS_H
 
+#include "compat.h"
+
+SUPPRESS_RUBY_HEADER_DIAGNOSTICS_BEGIN
+#include "ruby.h"
+SUPPRESS_RUBY_HEADER_DIAGNOSTICS_END
+
 extern VALUE RBS;
 
 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;
@@ -47,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/compat.h

@@ -0,0 +1,10 @@
+#ifdef __clang__
+#define SUPPRESS_RUBY_HEADER_DIAGNOSTICS_BEGIN \
+    _Pragma("clang diagnostic push")           \
+        _Pragma("clang diagnostic ignored \"-Wc2x-extensions\"")
+#define SUPPRESS_RUBY_HEADER_DIAGNOSTICS_END \
+    _Pragma("clang diagnostic pop")
+#else
+#define SUPPRESS_RUBY_HEADER_DIAGNOSTICS_BEGIN
+#define SUPPRESS_RUBY_HEADER_DIAGNOSTICS_END
+#endif

data/ext/rbs_extension/extconf.rb

@@ -11,5 +11,29 @@ root_dir = File.expand_path('../../../', __FILE__)
 $srcs = Dir.glob("#{root_dir}/src/**/*.c") +
         Dir.glob("#{root_dir}/ext/rbs_extension/*.c")
 
-append_cflags ['-std=gnu99']
+append_cflags [
+  '-std=gnu99',
+  '-Wimplicit-fallthrough',
+  '-Wunused-result',
+  '-Wc++-compat',
+]
+
+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"
+end
+
 create_makefile 'rbs_extension'
+
+# Only generate compile_commands.json when compiling through Rake tasks
+# This is to avoid adding extconf_compile_commands_json as a runtime dependency
+if ENV["COMPILE_COMMANDS_JSON"]
+  require 'extconf_compile_commands_json'
+  ExtconfCompileCommandsJson.generate!
+  ExtconfCompileCommandsJson.symlink!
+end

data/ext/rbs_extension/legacy_location.c

@@ -0,0 +1,294 @@
+#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)))
+#define RBS_LOC_CHILDREN_SIZE(cap) (sizeof(rbs_loc_children) + sizeof(rbs_loc_entry) * ((cap) - 1))
+#define NULL_LOC_RANGE_P(rg) ((rg).start == -1)
+
+rbs_loc_range RBS_LOC_NULL_RANGE = { -1, -1 };
+VALUE RBS_Location;
+
+static void check_children_max(unsigned short n) {
+    size_t max = sizeof(rbs_loc_entry_bitmap) * 8;
+    if (n > max) {
+        rb_raise(rb_eRuntimeError, "Too many children added to location: %d", n);
+    }
+}
+
+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 = (rbs_loc_children *) malloc(s);
+    *loc->children = (rbs_loc_children) {
+        .len = 0,
+        .required_p = 0,
+        .cap = cap,
+        .entries = { { 0 } },
+    };
+}
+
+static void check_children_cap(rbs_loc *loc) {
+    if (loc->children == NULL) {
+        rbs_loc_legacy_alloc_children(loc, 1);
+    } else {
+        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 = (rbs_loc_children *) realloc(loc->children, s);
+        }
+    }
+}
+
+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 = 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;
+    loc->children->required_p |= 1 << last_index;
+}
+
+void rbs_loc_init(rbs_loc *loc, VALUE buffer, rbs_loc_range rg) {
+    *loc = (rbs_loc) {
+        .buffer = buffer,
+        .rg = rg,
+        .children = NULL,
+    };
+}
+
+void rbs_loc_free(rbs_loc *loc) {
+    free(loc->children);
+    ruby_xfree(loc);
+}
+
+static void rbs_loc_mark(void *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 = (const rbs_loc *) ptr;
+    if (loc->children == NULL) {
+        return sizeof(rbs_loc);
+    } else {
+        return sizeof(rbs_loc) + RBS_LOC_CHILDREN_SIZE(loc->children->cap);
+    }
+}
+
+static rb_data_type_t location_type = {
+    "RBS::Location",
+    { rbs_loc_mark, (RUBY_DATA_FUNC) rbs_loc_free, rbs_loc_memsize },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE location_s_allocate(VALUE klass) {
+    rbs_loc *loc;
+    VALUE obj = TypedData_Make_Struct(klass, rbs_loc, &location_type, loc);
+
+    rbs_loc_init(loc, Qnil, RBS_LOC_NULL_RANGE);
+
+    return obj;
+}
+
+rbs_loc *rbs_check_location(VALUE obj) {
+    return (rbs_loc *) rb_check_typeddata(obj, &location_type);
+}
+
+static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {
+    rbs_loc *loc = rbs_check_location(self);
+
+    int start = FIX2INT(start_pos);
+    int end = FIX2INT(end_pos);
+
+    *loc = (rbs_loc) {
+        .buffer = buffer,
+        .rg = (rbs_loc_range) { start, end },
+        .children = NULL,
+    };
+
+    return Qnil;
+}
+
+static VALUE location_initialize_copy(VALUE self, VALUE other) {
+    rbs_loc *self_loc = rbs_check_location(self);
+    rbs_loc *other_loc = rbs_check_location(other);
+
+    *self_loc = (rbs_loc) {
+        .buffer = other_loc->buffer,
+        .rg = other_loc->rg,
+        .children = NULL,
+    };
+
+    if (other_loc->children != NULL) {
+        rbs_loc_legacy_alloc_children(self_loc, other_loc->children->cap);
+        memcpy(self_loc->children, other_loc->children, RBS_LOC_CHILDREN_SIZE(other_loc->children->cap));
+    }
+
+    return Qnil;
+}
+
+static VALUE location_buffer(VALUE self) {
+    rbs_loc *loc = rbs_check_location(self);
+    return loc->buffer;
+}
+
+static VALUE location_start_pos(VALUE self) {
+    rbs_loc *loc = rbs_check_location(self);
+    return INT2FIX(loc->rg.start);
+}
+
+static VALUE location_end_pos(VALUE self) {
+    rbs_loc *loc = rbs_check_location(self);
+    return INT2FIX(loc->rg.end);
+}
+
+static VALUE location_add_required_child(VALUE self, VALUE name, VALUE start, VALUE end) {
+    rbs_loc *loc = rbs_check_location(self);
+
+    rbs_loc_range rg = {
+        .start = FIX2INT(start),
+        .end = FIX2INT(end),
+    };
+
+    rbs_loc_legacy_add_required_child(loc, rb_sym2id(name), rg);
+
+    return Qnil;
+}
+
+static VALUE location_add_optional_child(VALUE self, VALUE name, VALUE start, VALUE end) {
+    rbs_loc *loc = rbs_check_location(self);
+
+    rbs_loc_range rg = {
+        .start = FIX2INT(start),
+        .end = FIX2INT(end),
+    };
+
+    rbs_loc_legacy_add_optional_child(loc, rb_sym2id(name), rg);
+
+    return Qnil;
+}
+
+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, rb_sym2id(name), RBS_LOC_NULL_RANGE);
+
+    return Qnil;
+}
+
+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_loc_range) { rg.start.char_pos, rg.end.char_pos });
+
+    return obj;
+}
+
+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, (rbs_loc_range) { .start = start_char, .end = end_char });
+
+    return obj;
+}
+
+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);
+
+    rbs_loc_init(loc, buffer, rg);
+
+    return obj;
+}
+
+static VALUE location_aref(VALUE self, VALUE name) {
+    rbs_loc *loc = rbs_check_location(self);
+
+    ID id = rb_sym2id(name);
+
+    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;
+
+                if (RBS_LOC_OPTIONAL_P(loc, i) && NULL_LOC_RANGE_P(result)) {
+                    return Qnil;
+                } else {
+                    return rbs_new_location_from_loc_range(loc->buffer, result);
+                }
+            }
+        }
+    }
+
+    VALUE string = rb_funcall(name, rb_intern("to_s"), 0);
+    rb_raise(rb_eRuntimeError, "Unknown child name given: %s", RSTRING_PTR(string));
+}
+
+static VALUE location_optional_keys(VALUE self) {
+    VALUE keys = rb_ary_new();
+
+    rbs_loc *loc = rbs_check_location(self);
+    rbs_loc_children *children = loc->children;
+    if (children == NULL) {
+        return keys;
+    }
+
+    for (unsigned short i = 0; i < children->len; i++) {
+        if (RBS_LOC_OPTIONAL_P(loc, i)) {
+            VALUE key_sym = rb_id2sym(children->entries[i].name);
+            rb_ary_push(keys, key_sym);
+        }
+    }
+
+    return keys;
+}
+
+static VALUE location_required_keys(VALUE self) {
+    VALUE keys = rb_ary_new();
+
+    rbs_loc *loc = rbs_check_location(self);
+    rbs_loc_children *children = loc->children;
+    if (children == NULL) {
+        return keys;
+    }
+
+    for (unsigned short i = 0; i < children->len; i++) {
+        if (RBS_LOC_REQUIRED_P(loc, i)) {
+            VALUE key_sym = rb_id2sym(children->entries[i].name);
+            rb_ary_push(keys, key_sym);
+        }
+    }
+
+    return keys;
+}
+
+void rbs__init_location(void) {
+    RBS_Location = rb_define_class_under(RBS, "Location", rb_cObject);
+    rb_define_alloc_func(RBS_Location, location_s_allocate);
+    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, "_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);
+    rb_define_method(RBS_Location, "_optional_keys", location_optional_keys, 0);
+    rb_define_method(RBS_Location, "_required_keys", location_required_keys, 0);
+    rb_define_method(RBS_Location, "[]", location_aref, 1);
+}

data/ext/rbs_extension/legacy_location.h

@@ -0,0 +1,82 @@
+#ifndef RBS_LOCATION_H
+#define RBS_LOCATION_H
+
+#include "compat.h"
+
+SUPPRESS_RUBY_HEADER_DIAGNOSTICS_BEGIN
+#include "ruby.h"
+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;
+    rbs_loc_children *children; // NULL when no children is allocated
+} rbs_loc;
+
+/**
+ * Returns new RBS::Location object, with given buffer and range.
+ * */
+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.
+ * */
+rbs_loc *rbs_check_location(VALUE location);
+
+/**
+ * Allocate memory for child locations.
+ *
+ * Do not call twice for the same 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.
+ * */
+void rbs__init_location();
+
+#endif