rbs 3.6.1 → 3.9.5

data/ext/rbs_extension/location.c

@@ -36,9 +36,12 @@ void rbs_loc_alloc_children(rbs_loc *loc, unsigned short cap) {
   size_t s = RBS_LOC_CHILDREN_SIZE(cap);
   loc->children = malloc(s);
 
-  loc->children->len = 0;
-  loc->children->required_p = 0;
-  loc->children->cap = cap;
+  *loc->children = (rbs_loc_children) {
+    .len = 0,
+    .required_p = 0,
+    .cap = cap,
+    .entries = {{ 0 }},
+  };
 }
 
 static void check_children_cap(rbs_loc *loc) {
@@ -53,28 +56,29 @@ static void check_children_cap(rbs_loc *loc) {
   }
 }
 
-void rbs_loc_add_required_child(rbs_loc *loc, ID name, range r) {
-  check_children_cap(loc);
-
-  unsigned short i = loc->children->len++;
-  loc->children->entries[i].name = name;
-  loc->children->entries[i].rg = rbs_new_loc_range(r);
+void rbs_loc_add_required_child(rbs_loc *loc, rbs_constant_id_t name, range r) {
+  rbs_loc_add_optional_child(loc, name, r);
 
-  loc->children->required_p |= 1 << i;
+  unsigned short last_index = loc->children->len - 1;
+  loc->children->required_p |= 1 << last_index;
 }
 
-void rbs_loc_add_optional_child(rbs_loc *loc, ID name, range r) {
+void rbs_loc_add_optional_child(rbs_loc *loc, rbs_constant_id_t name, range r) {
   check_children_cap(loc);
 
   unsigned short i = loc->children->len++;
-  loc->children->entries[i].name = name;
-  loc->children->entries[i].rg = rbs_new_loc_range(r);
+  loc->children->entries[i] = (rbs_loc_entry) {
+    .name = name,
+    .rg = rbs_new_loc_range(r),
+  };
 }
 
 void rbs_loc_init(rbs_loc *loc, VALUE buffer, rbs_loc_range rg) {
-  loc->buffer = buffer;
-  loc->rg = rg;
-  loc->children = NULL;
+  *loc = (rbs_loc) {
+    .buffer = buffer,
+    .rg = rg,
+    .children = NULL,
+  };
 }
 
 void rbs_loc_free(rbs_loc *loc) {
@@ -122,9 +126,11 @@ static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALU
   int start = FIX2INT(start_pos);
   int end = FIX2INT(end_pos);
 
-  loc->buffer = buffer;
-  loc->rg.start = start;
-  loc->rg.end = end;
+  *loc = (rbs_loc) {
+    .buffer = buffer,
+    .rg = (rbs_loc_range) { start, end },
+    .children = NULL,
+  };
 
   return Qnil;
 }
@@ -133,8 +139,12 @@ 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->buffer = other_loc->buffer;
-  self_loc->rg = other_loc->rg;
+  *self_loc = (rbs_loc) {
+    .buffer = other_loc->buffer,
+    .rg = other_loc->rg,
+    .children = NULL,
+  };
+
   if (other_loc->children != NULL) {
     rbs_loc_alloc_children(self_loc, other_loc->children->cap);
     memcpy(self_loc->children, other_loc->children, RBS_LOC_CHILDREN_SIZE(other_loc->children->cap));
@@ -158,6 +168,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);
 
@@ -165,7 +184,7 @@ static VALUE location_add_required_child(VALUE self, VALUE name, VALUE start, VA
   rg.start = rbs_loc_position(FIX2INT(start));
   rg.end = rbs_loc_position(FIX2INT(end));
 
-  rbs_loc_add_required_child(loc, SYM2ID(name), rg);
+  rbs_loc_add_required_child(loc, rbs_constant_pool_insert_ruby_symbol(name), rg);
 
   return Qnil;
 }
@@ -177,7 +196,7 @@ static VALUE location_add_optional_child(VALUE self, VALUE name, VALUE start, VA
   rg.start = rbs_loc_position(FIX2INT(start));
   rg.end = rbs_loc_position(FIX2INT(end));
 
-  rbs_loc_add_optional_child(loc, SYM2ID(name), rg);
+  rbs_loc_add_optional_child(loc, rbs_constant_pool_insert_ruby_symbol(name), rg);
 
   return Qnil;
 }
@@ -185,7 +204,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_add_optional_child(loc, SYM2ID(name), NULL_RANGE);
+  rbs_loc_add_optional_child(loc, rbs_constant_pool_insert_ruby_symbol(name), NULL_RANGE);
 
   return Qnil;
 }
@@ -208,12 +227,18 @@ static VALUE rbs_new_location_from_loc_range(VALUE buffer, rbs_loc_range rg) {
   return obj;
 }
 
+static rbs_constant_id_t rbs_constant_pool_find_ruby_symbol(VALUE symbol) {
+  VALUE name = rb_sym2str(symbol);
+
+  return rbs_constant_pool_find(RBS_GLOBAL_CONSTANT_POOL, (const uint8_t *) RSTRING_PTR(name), RSTRING_LEN(name));
+}
+
 static VALUE location_aref(VALUE self, VALUE name) {
   rbs_loc *loc = rbs_check_location(self);
 
-  ID id = SYM2ID(name);
+  rbs_constant_id_t id = rbs_constant_pool_find_ruby_symbol(name);
 
-  if (loc->children != NULL) {
+  if (loc->children != NULL && id != RBS_CONSTANT_ID_UNSET) {
     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;
@@ -231,6 +256,10 @@ 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();
 
@@ -242,8 +271,9 @@ static VALUE location_optional_keys(VALUE self) {
 
   for (unsigned short i = 0; i < children->len; i++) {
     if (RBS_LOC_OPTIONAL_P(loc, i)) {
-      rb_ary_push(keys, ID2SYM(children->entries[i].name));
-
+      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);
+      rb_ary_push(keys, key_sym);
     }
   }
 
@@ -261,7 +291,9 @@ static VALUE location_required_keys(VALUE self) {
 
   for (unsigned short i = 0; i < children->len; i++) {
     if (RBS_LOC_REQUIRED_P(loc, i)) {
-      rb_ary_push(keys, ID2SYM(children->entries[i].name));
+      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);
+      rb_ary_push(keys, key_sym);
     }
   }
 

data/ext/rbs_extension/location.h

@@ -3,6 +3,7 @@
 
 #include "ruby.h"
 #include "lexer.h"
+#include "rbs/util/rbs_constant_pool.h"
 
 /**
  * RBS::Location class
@@ -15,7 +16,7 @@ typedef struct {
 } rbs_loc_range;
 
 typedef struct {
-  ID name;
+  rbs_constant_id_t name;
   rbs_loc_range rg;
 } rbs_loc_entry;
 
@@ -58,14 +59,14 @@ void rbs_loc_alloc_children(rbs_loc *loc, unsigned short cap);
  *
  * Allocate memory for children with rbs_loc_alloc_children before calling this function.
  * */
-void rbs_loc_add_required_child(rbs_loc *loc, ID name, range r);
+void rbs_loc_add_required_child(rbs_loc *loc, rbs_constant_id_t name, range r);
 
 /**
  * Add an optional child range with given name.
  *
  * Allocate memory for children with rbs_loc_alloc_children before calling this function.
  * */
-void rbs_loc_add_optional_child(rbs_loc *loc, ID name, range r);
+void rbs_loc_add_optional_child(rbs_loc *loc, rbs_constant_id_t name, range r);
 
 /**
  * Returns RBS::Location object with start/end positions.

data/ext/rbs_extension/main.c

@@ -1,12 +1,34 @@
 #include "rbs_extension.h"
+#include "rbs/util/rbs_constant_pool.h"
+
+#include "ruby/vm.h"
+
+static
+void Deinit_rbs_extension(ruby_vm_t *_) {
+  rbs_constant_pool_free(RBS_GLOBAL_CONSTANT_POOL);
+}
 
 void
 Init_rbs_extension(void)
 {
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
   rb_ext_ractor_safe(true);
-#endif  
+#endif
   rbs__init_constants();
   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);
 }