Use rbs_constant_pool for typevar table

Author: amomchilov

ext/rbs_extension/parser.c

@@ -1031,8 +1031,13 @@ static VALUE parse_simple(parserstate *state) {
     return parse_symbol(state);
   }
   case tUIDENT: {
-    ID name = INTERN_TOKEN(state, state->current_token);
+    const char *name_str = peek_token(state->lexstate, state->current_token);
+    size_t name_len = token_bytes(state->current_token);
+
+    rbs_constant_id_t name = rbs_constant_pool_find(&state->constant_pool, (const uint8_t *) name_str, name_len);
+
     if (parser_typevar_member(state, name)) {
+      ID name = rb_intern3(name_str, name_len, rb_enc_get(state->lexstate->string));
       return rbs_variable(ID2SYM(name), rbs_location_current_token(state));
     }
     // fallthrough for type name
@@ -1190,8 +1195,13 @@ static VALUE parse_type_params(parserstate *state, range *rg, bool module_type_p
       parser_advance_assert(state, tUIDENT);
       range name_range = state->current_token.range;
 
-      ID id = INTERN_TOKEN(state, state->current_token);
-      VALUE name = ID2SYM(id);
+      rbs_constant_id_t id = rbs_constant_pool_insert_shared(
+        &state->constant_pool,
+        (const uint8_t *) peek_token(state->lexstate, state->current_token),
+        token_bytes(state->current_token)
+      );
+
+      VALUE name = ID2SYM(INTERN_TOKEN(state, state->current_token));
 
       parser_insert_typevar(state, id);
 

ext/rbs_extension/parserstate.c

@@ -1,4 +1,5 @@
 #include "rbs_extension.h"
+#include "rbs/util/rbs_constant_pool.h"
 
 #define RESET_TABLE_P(table) (table->size == 0)
 
@@ -8,7 +9,7 @@ id_table *alloc_empty_table(void) {
   *table = (id_table) {
     .size = 10,
     .count = 0,
-    .ids = calloc(10, sizeof(ID)),
+    .ids = calloc(10, sizeof(rbs_constant_id_t)),
     .next = NULL,
   };
 
@@ -61,7 +62,7 @@ void parser_pop_typevar_table(parserstate *state) {
   }
 }
 
-void parser_insert_typevar(parserstate *state, ID id) {
+void parser_insert_typevar(parserstate *state, rbs_constant_id_t id) {
   id_table *table = state->vars;
 
   if (RESET_TABLE_P(table)) {
@@ -70,17 +71,17 @@ void parser_insert_typevar(parserstate *state, ID id) {
 
   if (table->size == table->count) {
     // expand
-    ID *ptr = table->ids;
+    rbs_constant_id_t *ptr = table->ids;
     table->size += 10;
-    table->ids = calloc(table->size, sizeof(ID));
-    memcpy(table->ids, ptr, sizeof(ID) * table->count);
+    table->ids = calloc(table->size, sizeof(rbs_constant_id_t));
+    memcpy(table->ids, ptr, sizeof(rbs_constant_id_t) * table->count);
     free(ptr);
   }
 
   table->ids[table->count++] = id;
 }
 
-bool parser_typevar_member(parserstate *state, ID id) {
+bool parser_typevar_member(parserstate *state, rbs_constant_id_t id) {
   id_table *table = state->vars;
 
   while (table && !RESET_TABLE_P(table)) {
@@ -332,8 +333,12 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
 
     .vars = NULL,
     .last_comment = NULL,
+
+    .constant_pool = {},
   };
 
+  rbs_constant_pool_init(&parser->constant_pool, 0);
+
   parser_advance(parser);
   parser_advance(parser);
   parser_advance(parser);
@@ -350,7 +355,15 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
     for (long i = 0; i < rb_array_len(variables); i++) {
       VALUE index = INT2FIX(i);
       VALUE symbol = rb_ary_aref(1, &index, variables);
-      parser_insert_typevar(parser, SYM2ID(symbol));
+      VALUE name = rb_sym2str(symbol);
+
+      rbs_constant_id_t id = rbs_constant_pool_insert_shared(
+        &parser->constant_pool,
+        (const uint8_t *) RSTRING_PTR(name),
+        RSTRING_LEN(name)
+      );
+
+      parser_insert_typevar(parser, id);
     }
   }
 
@@ -362,5 +375,6 @@ void free_parser(parserstate *parser) {
   if (parser->last_comment) {
     free_comment(parser->last_comment);
   }
+  rbs_constant_pool_free(&parser->constant_pool);
   free(parser);
 }

ext/rbs_extension/parserstate.h

@@ -7,13 +7,13 @@
 #include "location.h"
 
 /**
- * id_table represents a set of IDs.
+ * id_table represents a set of RBS constant IDs.
  * This is used to manage the set of bound variables.
  * */
 typedef struct id_table {
   size_t size;
   size_t count;
-  ID *ids;
+  rbs_constant_id_t *ids;
   struct id_table *next;
 } id_table;
 
@@ -55,6 +55,8 @@ typedef struct {
 
   id_table *vars;         /* Known type variables */
   comment *last_comment;  /* Last read comment */
+
+  rbs_constant_pool_t constant_pool;
 } parserstate;
 
 comment *alloc_comment(token comment_token, comment *last_comment);
@@ -84,14 +86,14 @@ void parser_pop_typevar_table(parserstate *state);
 /**
  * Insert new type variable into the latest table.
  * */
-void parser_insert_typevar(parserstate *state, ID id);
+void parser_insert_typevar(parserstate *state, rbs_constant_id_t id);
 
 /**
  * Returns true if given type variable is recorded in the table.
  * If not found, it goes one table up, if it's not a reset table.
  * Or returns false, if it's a reset table.
  * */
-bool parser_typevar_member(parserstate *state, ID id);
+bool parser_typevar_member(parserstate *state, rbs_constant_id_t id);
 
 /**
  * Allocate new lexstate object.