rbs 3.6.1 → 3.9.5

data/ext/rbs_extension/parserstate.c

@@ -1,19 +1,30 @@
 #include "rbs_extension.h"
+#include "rbs/util/rbs_constant_pool.h"
 
 #define RESET_TABLE_P(table) (table->size == 0)
 
 id_table *alloc_empty_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 10;
-  table->count = 0;
-  table->ids = calloc(10, sizeof(ID));
+
+  *table = (id_table) {
+    .size = 10,
+    .count = 0,
+    .ids = calloc(10, sizeof(rbs_constant_id_t)),
+    .next = NULL,
+  };
 
   return table;
 }
 
 id_table *alloc_reset_table(void) {
   id_table *table = malloc(sizeof(id_table));
-  table->size = 0;
+
+  *table = (id_table) {
+    .size = 0,
+    .count = 0,
+    .ids = NULL,
+    .next = NULL,
+  };
 
   return table;
 }
@@ -51,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)) {
@@ -60,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)) {
@@ -182,15 +193,18 @@ VALUE get_comment(parserstate *state, int subject_line) {
 }
 
 comment *alloc_comment(token comment_token, comment *last_comment) {
-  comment *new_comment = calloc(1, sizeof(comment));
+  comment *new_comment = malloc(sizeof(comment));
 
-  new_comment->next_comment = last_comment;
+  *new_comment = (comment) {
+    .start = comment_token.range.start,
+    .end = comment_token.range.end,
 
-  new_comment->start = comment_token.range.start;
-  new_comment->end = comment_token.range.end;
+    .line_size = 0,
+    .line_count = 0,
+    .tokens = NULL,
 
-  new_comment->line_size = 0;
-  new_comment->line_count = 0;
+    .next_comment = last_comment,
+  };
 
   comment_insert_new_line(new_comment, comment_token);
 
@@ -279,11 +293,25 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
     rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
   }
 
-  lexstate *lexer = calloc(1, sizeof(lexstate));
-  lexer->string = string;
-  lexer->current.line = 1;
-  lexer->start_pos = start_pos;
-  lexer->end_pos = end_pos;
+  lexstate *lexer = malloc(sizeof(lexstate));
+
+  position start_position = (position) {
+    .byte_pos = 0,
+    .char_pos = 0,
+    .line = 1,
+    .column = 0,
+  };
+
+  *lexer = (lexstate) {
+    .string = string,
+    .start_pos = start_pos,
+    .end_pos = end_pos,
+    .current = start_position,
+    .start = { 0 },
+    .first_token_of_line = false,
+    .last_char = 0,
+  };
+
   skipn(lexer, start_pos);
   lexer->start = lexer->current;
   lexer->first_token_of_line = lexer->current.column == 0;
@@ -292,13 +320,42 @@ lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
 }
 
 parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_pos, VALUE variables) {
-  parserstate *parser = calloc(1, sizeof(parserstate));
-  parser->lexstate = lexer;
-  parser->buffer = buffer;
-  parser->current_token = NullToken;
-  parser->next_token = NullToken;
-  parser->next_token2 = NullToken;
-  parser->next_token3 = NullToken;
+  parserstate *parser = malloc(sizeof(parserstate));
+
+  *parser = (parserstate) {
+    .lexstate = lexer,
+
+    .current_token = NullToken,
+    .next_token = NullToken,
+    .next_token2 = NullToken,
+    .next_token3 = NullToken,
+    .buffer = buffer,
+
+    .vars = NULL,
+    .last_comment = NULL,
+
+    .constant_pool = { 0 },
+  };
+
+  // The parser's constant pool is mainly used for storing the names of type variables, which usually aren't many.
+  // Below are some statistics gathered from the current test suite. We can see that 56% of parsers never add to their
+  // constant pool at all. The initial capacity needs to be a power of 2. Picking 2 means that we won't need to realloc
+  // in 85% of cases.
+  //
+  // TODO: recalculate these statistics based on a real world codebase, rather than the test suite.
+  //
+  // | Size | Count | Cumulative | % Coverage |
+  // |------|-------|------------|------------|
+  // |   0  | 7,862 |      7,862 |     56%    |
+  // |   1  | 3,196 |     11,058 |     79%    |
+  // |   2  |   778 |     12,719 |     85%    |
+  // |   3  |   883 |     11,941 |     91%    |
+  // |   4  |   478 |     13,197 |     95%    |
+  // |   5  |   316 |     13,513 |     97%    |
+  // |   6  |   288 |     13,801 |     99%    |
+  // |   7  |   144 |     13,945 |    100%    |
+  const size_t initial_pool_capacity = 2;
+  rbs_constant_pool_init(&parser->constant_pool, initial_pool_capacity);
 
   parser_advance(parser);
   parser_advance(parser);
@@ -306,6 +363,7 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
 
   if (!NIL_P(variables)) {
     if (!RB_TYPE_P(variables, T_ARRAY)) {
+      free_parser(parser);
       rb_raise(rb_eTypeError,
                "wrong argument type %"PRIsVALUE" (must be array or nil)",
                rb_obj_class(variables));
@@ -314,19 +372,40 @@ parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_
     parser_push_typevar_table(parser, true);
 
     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 symbol = rb_ary_entry(variables, i);
+      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);
     }
   }
 
   return parser;
 }
 
+void free_typevar_tables(id_table *table) {
+  while (table != NULL) {
+    id_table *next = table->next;
+    if (table->ids != NULL) {
+      free(table->ids);
+    }
+    free(table);
+    table = next;
+  }
+}
+
 void free_parser(parserstate *parser) {
   free(parser->lexstate);
   if (parser->last_comment) {
     free_comment(parser->last_comment);
   }
+
+  free_typevar_tables(parser->vars);
+  rbs_constant_pool_free(&parser->constant_pool);
   free(parser);
 }

data/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.

data/ext/rbs_extension/rbs_extension.h

@@ -4,18 +4,9 @@
 #include "ruby/re.h"
 #include "ruby/encoding.h"
 
+#include "rbs.h"
 #include "lexer.h"
 #include "parser.h"
-#include "constants.h"
-#include "ruby_objs.h"
-
-/**
- * Unescape escape sequences in the given string inplace:
- *
- *   '\\n' => "\n"
- *
- * */
-void rbs_unescape_string(VALUE string, bool dq_string);
 
 /**
  * Receives `parserstate` and `range`, which represents a string token or symbol token, and returns a string VALUE.

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

@@ -1,31 +1,38 @@
+/*----------------------------------------------------------------------------*/
+/* 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                                      */
+/*----------------------------------------------------------------------------*/
+
 #ifndef RBS__CONSTANTS_H
 #define RBS__CONSTANTS_H
 
 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_Types;
+extern VALUE RBS_Types_Bases;
+extern VALUE RBS_ParsingError;
+
 extern VALUE RBS_AST_Annotation;
 extern VALUE RBS_AST_Comment;
-extern VALUE RBS_AST_TypeParam;
-
-extern VALUE RBS_AST_Declarations;
-extern VALUE RBS_AST_Declarations_TypeAlias;
-extern VALUE RBS_AST_Declarations_Class_Super;
 extern VALUE RBS_AST_Declarations_Class;
+extern VALUE RBS_AST_Declarations_Class_Super;
+extern VALUE RBS_AST_Declarations_ClassAlias;
 extern VALUE RBS_AST_Declarations_Constant;
 extern VALUE RBS_AST_Declarations_Global;
 extern VALUE RBS_AST_Declarations_Interface;
-extern VALUE RBS_AST_Declarations_Module_Self;
 extern VALUE RBS_AST_Declarations_Module;
+extern VALUE RBS_AST_Declarations_Module_Self;
 extern VALUE RBS_AST_Declarations_ModuleAlias;
-extern VALUE RBS_AST_Declarations_ClassAlias;
-
-extern VALUE RBS_AST_Directives;
+extern VALUE RBS_AST_Declarations_TypeAlias;
 extern VALUE RBS_AST_Directives_Use;
 extern VALUE RBS_AST_Directives_Use_SingleClause;
 extern VALUE RBS_AST_Directives_Use_WildcardClause;
-
-extern VALUE RBS_AST_Members;
 extern VALUE RBS_AST_Members_Alias;
 extern VALUE RBS_AST_Members_AttrAccessor;
 extern VALUE RBS_AST_Members_AttrReader;
@@ -40,16 +47,11 @@ 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_TypeParam;
 extern VALUE RBS_MethodType;
 extern VALUE RBS_Namespace;
-
-extern VALUE RBS_ParsingError;
 extern VALUE RBS_TypeName;
-
-extern VALUE RBS_Types;
 extern VALUE RBS_Types_Alias;
-extern VALUE RBS_Types_Bases;
 extern VALUE RBS_Types_Bases_Any;
 extern VALUE RBS_Types_Bases_Bool;
 extern VALUE RBS_Types_Bases_Bottom;
@@ -62,9 +64,8 @@ extern VALUE RBS_Types_Bases_Void;
 extern VALUE RBS_Types_Block;
 extern VALUE RBS_Types_ClassInstance;
 extern VALUE RBS_Types_ClassSingleton;
-extern VALUE RBS_Types_Function_Param;
 extern VALUE RBS_Types_Function;
-extern VALUE RBS_Types_UntypedFunction;
+extern VALUE RBS_Types_Function_Param;
 extern VALUE RBS_Types_Interface;
 extern VALUE RBS_Types_Intersection;
 extern VALUE RBS_Types_Literal;
@@ -73,6 +74,7 @@ extern VALUE RBS_Types_Proc;
 extern VALUE RBS_Types_Record;
 extern VALUE RBS_Types_Tuple;
 extern VALUE RBS_Types_Union;
+extern VALUE RBS_Types_UntypedFunction;
 extern VALUE RBS_Types_Variable;
 
 void rbs__init_constants();

data/include/rbs/ruby_objs.h

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually.                                                      */
+/* To change the template see                                                 */
+/* templates/include/rbs/ruby_objs.h.erb                                      */
+/*----------------------------------------------------------------------------*/
+
+#ifndef RBS__RUBY_OBJS_H
+#define RBS__RUBY_OBJS_H
+
+#include "ruby.h"
+
+VALUE rbs_ast_annotation(VALUE string, VALUE location);
+VALUE rbs_ast_comment(VALUE string, VALUE location);
+VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment, VALUE annotations);
+VALUE rbs_ast_decl_type_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_directives_use(VALUE clauses, VALUE location);
+VALUE rbs_ast_directives_use_single_clause(VALUE type_name, VALUE new_name, VALUE location);
+VALUE rbs_ast_directives_use_wildcard_clause(VALUE namespace, VALUE location);
+VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_attr_accessor(VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
+VALUE rbs_ast_members_attr_reader(VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
+VALUE rbs_ast_members_attr_writer(VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
+VALUE rbs_ast_members_class_instance_variable(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_members_class_variable(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_members_extend(VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_include(VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_instance_variable(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE overloads, VALUE annotations, VALUE location, VALUE comment, VALUE overloading, VALUE visibility);
+VALUE rbs_ast_members_method_definition_overload(VALUE annotations, VALUE method_type);
+VALUE rbs_ast_members_prepend(VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_private(VALUE location);
+VALUE rbs_ast_members_public(VALUE location);
+VALUE rbs_ast_type_param(VALUE name, VALUE variance, VALUE upper_bound, VALUE default_type, VALUE unchecked, VALUE location);
+VALUE rbs_method_type(VALUE type_params, VALUE type, VALUE block, VALUE location);
+VALUE rbs_namespace(VALUE path, VALUE absolute);
+VALUE rbs_type_name(VALUE namespace, VALUE name);
+VALUE rbs_alias(VALUE name, VALUE args, VALUE location);
+VALUE rbs_bases_any(VALUE todo, VALUE location);
+VALUE rbs_bases_bool(VALUE location);
+VALUE rbs_bases_bottom(VALUE location);
+VALUE rbs_bases_class(VALUE location);
+VALUE rbs_bases_instance(VALUE location);
+VALUE rbs_bases_nil(VALUE location);
+VALUE rbs_bases_self(VALUE location);
+VALUE rbs_bases_top(VALUE location);
+VALUE rbs_bases_void(VALUE location);
+VALUE rbs_block(VALUE type, VALUE required, VALUE self_type);
+VALUE rbs_class_instance(VALUE name, VALUE args, VALUE location);
+VALUE rbs_class_singleton(VALUE name, VALUE location);
+VALUE rbs_function(VALUE required_positionals, VALUE optional_positionals, VALUE rest_positionals, VALUE trailing_positionals, VALUE required_keywords, VALUE optional_keywords, VALUE rest_keywords, VALUE return_type);
+VALUE rbs_function_param(VALUE type, VALUE name, VALUE location);
+VALUE rbs_interface(VALUE name, VALUE args, VALUE location);
+VALUE rbs_intersection(VALUE types, VALUE location);
+VALUE rbs_literal(VALUE literal, VALUE location);
+VALUE rbs_optional(VALUE type, VALUE location);
+VALUE rbs_proc(VALUE type, VALUE block, VALUE location, VALUE self_type);
+VALUE rbs_record(VALUE all_fields, VALUE location);
+VALUE rbs_tuple(VALUE types, VALUE location);
+VALUE rbs_union(VALUE types, VALUE location);
+VALUE rbs_untyped_function(VALUE return_type);
+VALUE rbs_variable(VALUE name, VALUE location);
+
+#endif

data/include/rbs/util/rbs_constant_pool.h

@@ -0,0 +1,219 @@
+/**
+ * @file rbs_constant_pool.h
+ *
+ * A data structure that stores a set of strings.
+ *
+ * Each string is assigned a unique id, which can be used to compare strings for
+ * equality. This comparison ends up being much faster than strcmp, since it
+ * only requires a single integer comparison.
+ */
+#ifndef RBS_CONSTANT_POOL_H
+#define RBS_CONSTANT_POOL_H
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * When we allocate constants into the pool, we reserve 0 to mean that the slot
+ * is not yet filled. This constant is reused in other places to indicate the
+ * lack of a constant id.
+ */
+#define RBS_CONSTANT_ID_UNSET 0
+
+/**
+ * A constant id is a unique identifier for a constant in the constant pool.
+ */
+typedef uint32_t rbs_constant_id_t;
+
+/**
+ * A list of constant IDs. Usually used to represent a set of locals.
+ */
+typedef struct {
+    /** The number of constant ids in the list. */
+    size_t size;
+
+    /** The number of constant ids that have been allocated in the list. */
+    size_t capacity;
+
+    /** The constant ids in the list. */
+    rbs_constant_id_t *ids;
+} rbs_constant_id_list_t;
+
+/**
+ * Initialize a list of constant ids.
+ *
+ * @param list The list to initialize.
+ */
+void rbs_constant_id_list_init(rbs_constant_id_list_t *list);
+
+/**
+ * Initialize a list of constant ids with a given capacity.
+ *
+ * @param list The list to initialize.
+ * @param capacity The initial capacity of the list.
+ */
+void rbs_constant_id_list_init_capacity(rbs_constant_id_list_t *list, size_t capacity);
+
+/**
+ * Append a constant id to a list of constant ids. Returns false if any
+ * potential reallocations fail.
+ *
+ * @param list The list to append to.
+ * @param id The id to append.
+ * @return Whether the append succeeded.
+ */
+bool rbs_constant_id_list_append(rbs_constant_id_list_t *list, rbs_constant_id_t id);
+
+/**
+ * Insert a constant id into a list of constant ids at the specified index.
+ *
+ * @param list The list to insert into.
+ * @param index The index at which to insert.
+ * @param id The id to insert.
+ */
+void rbs_constant_id_list_insert(rbs_constant_id_list_t *list, size_t index, rbs_constant_id_t id);
+
+/**
+ * Checks if the current constant id list includes the given constant id.
+ *
+ * @param list The list to check.
+ * @param id The id to check for.
+ * @return Whether the list includes the given id.
+ */
+bool rbs_constant_id_list_includes(rbs_constant_id_list_t *list, rbs_constant_id_t id);
+
+/**
+ * Free the memory associated with a list of constant ids.
+ *
+ * @param list The list to free.
+ */
+void rbs_constant_id_list_free(rbs_constant_id_list_t *list);
+
+/**
+ * The type of bucket in the constant pool hash map. This determines how the
+ * bucket should be freed.
+ */
+typedef unsigned int rbs_constant_pool_bucket_type_t;
+
+/** By default, each constant is a slice of the source. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_DEFAULT = 0;
+
+/** An owned constant is one for which memory has been allocated. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_OWNED = 1;
+
+/** A constant constant is known at compile time. */
+static const rbs_constant_pool_bucket_type_t RBS_CONSTANT_POOL_BUCKET_CONSTANT = 2;
+
+/** A bucket in the hash map. */
+typedef struct {
+    /** The incremental ID used for indexing back into the pool. */
+    unsigned int id: 30;
+
+    /** The type of the bucket, which determines how to free it. */
+    rbs_constant_pool_bucket_type_t type: 2;
+
+    /** The hash of the bucket. */
+    uint32_t hash;
+} rbs_constant_pool_bucket_t;
+
+/** A constant in the pool which effectively stores a string. */
+typedef struct {
+    /** A pointer to the start of the string. */
+    const uint8_t *start;
+
+    /** The length of the string. */
+    size_t length;
+} rbs_constant_t;
+
+/** The overall constant pool, which stores constants found while parsing. */
+typedef struct {
+    /** The buckets in the hash map. */
+    rbs_constant_pool_bucket_t *buckets;
+
+    /** The constants that are stored in the buckets. */
+    rbs_constant_t *constants;
+
+    /** The number of buckets in the hash map. */
+    uint32_t size;
+
+    /** The number of buckets that have been allocated in the hash map. */
+    uint32_t capacity;
+} rbs_constant_pool_t;
+
+// A global constant pool for storing permenant keywords, such as the names of location children in `parser.c`.
+extern rbs_constant_pool_t *RBS_GLOBAL_CONSTANT_POOL;
+
+/**
+ * Initialize a new constant pool with a given capacity.
+ *
+ * @param pool The pool to initialize.
+ * @param capacity The initial capacity of the pool.
+ * @return Whether the initialization succeeded.
+ */
+bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity);
+
+/**
+ * Return a pointer to the constant indicated by the given constant id.
+ *
+ * @param pool The pool to get the constant from.
+ * @param constant_id The id of the constant to get.
+ * @return A pointer to the constant.
+ */
+rbs_constant_t * rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id);
+
+/**
+ * Find a constant in a constant pool. Returns the id of the constant, or 0 if
+ * the constant is not found.
+ *
+ * @param pool The pool to find the constant in.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_find(const rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+/**
+ * Insert a constant into a constant pool that is a slice of a source string.
+ * Returns the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_shared(rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+/**
+ * Insert a constant into a constant pool from memory that is now owned by the
+ * constant pool. Returns the id of the constant, or 0 if any potential calls to
+ * resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_owned(rbs_constant_pool_t *pool, uint8_t *start, size_t length);
+
+/**
+ * Insert a constant into a constant pool from memory that is constant. Returns
+ * the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
+rbs_constant_id_t rbs_constant_pool_insert_constant(rbs_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+/**
+ * Free the memory associated with a constant pool.
+ *
+ * @param pool The pool to free.
+ */
+void rbs_constant_pool_free(rbs_constant_pool_t *pool);
+
+#endif

data/include/rbs.h

@@ -0,0 +1,7 @@
+#ifndef RBS_H
+#define RBS_H
+
+#include "rbs/constants.h"
+#include "rbs/ruby_objs.h"
+
+#endif