Remove string type enum

Since we don't manually allocate/free strings anymore, we don't need the string type enum
and all the complexity that comes with it.

ext/rbs_extension/rbs_string_bridging.c

@@ -1,7 +1,7 @@
 #include "rbs_string_bridging.h"
 
 rbs_string_t rbs_string_from_ruby_string(VALUE ruby_string) {
-    return rbs_string_shared_new(StringValueCStr(ruby_string), RSTRING_END(ruby_string));
+    return rbs_string_new(StringValueCStr(ruby_string), RSTRING_END(ruby_string));
 }
 
 VALUE rbs_string_to_ruby_string(rbs_string_t *self, rb_encoding *encoding) {

include/rbs/rbs_string.h

@@ -8,32 +8,17 @@
 typedef struct {
   const char *start;
   const char *end;
-
-  enum rbs_string_type {
-    /** This string is a constant string, and should not be freed. */
-    RBS_STRING_CONSTANT,
-    /** This is a slice of another string, and should not be freed. */
-    RBS_STRING_SHARED,
-    /** This string owns its memory, and will be freed when the allocator is freed. */
-    RBS_STRING_OWNED,
-  } type;
 } rbs_string_t;
 
 #define RBS_STRING_NULL ((rbs_string_t) { \
     .start = NULL,                        \
     .end = NULL,                          \
-    .type = RBS_STRING_CONSTANT,          \
   })
 
 /**
- * Returns a new `rbs_string_t` struct that points to the given C string without owning it.
- */
-rbs_string_t rbs_string_shared_new(const char *start, const char *end);
-
-/**
- * Returns a new `rbs_string_t` struct that owns its memory.
+ * Returns a new `rbs_string_t` struct
  */
-rbs_string_t rbs_string_owned_new(const char *start, const char *end);
+rbs_string_t rbs_string_new(const char *start, const char *end);
 
 /**
  * Copies a portion of the input string into a new owned string.

src/ast.c

@@ -1279,7 +1279,6 @@ void rbs_node_destroy(rbs_node_t *any_node) {
     case RBS_AST_ANNOTATION: {
         rbs_ast_annotation_t *node = (rbs_ast_annotation_t *)any_node;
 
-        // string is a string, so it will be freed when the allocator is freed.
         break;
     }
 #line 202 "prism/templates/src/ast.c.erb"
@@ -1290,7 +1289,6 @@ void rbs_node_destroy(rbs_node_t *any_node) {
     case RBS_AST_COMMENT: {
         rbs_ast_comment_t *node = (rbs_ast_comment_t *)any_node;
 
-        // string is a string, so it will be freed when the allocator is freed.
         break;
     }
 #line 202 "prism/templates/src/ast.c.erb"
@@ -1471,7 +1469,6 @@ void rbs_node_destroy(rbs_node_t *any_node) {
     case RBS_AST_INTEGER: {
         rbs_ast_integer_t *node = (rbs_ast_integer_t *)any_node;
 
-        // string_representation is a string, so it will be freed when the allocator is freed.
         break;
     }
 #line 202 "prism/templates/src/ast.c.erb"
@@ -1698,7 +1695,6 @@ void rbs_node_destroy(rbs_node_t *any_node) {
     case RBS_AST_STRING: {
         rbs_ast_string_t *node = (rbs_ast_string_t *)any_node;
 
-        // string is a string, so it will be freed when the allocator is freed.
         break;
     }
 #line 202 "prism/templates/src/ast.c.erb"

src/lexstate.c

@@ -110,11 +110,10 @@ unsigned int peek(lexstate *state) {
     state->last_char = '\0';
     return 0;
   } else {
-    rbs_string_t str = {
-      .start = state->string.start + state->current.byte_pos,
-      .end = state->string.end,
-      .type = RBS_STRING_SHARED,
-    };
+    rbs_string_t str = rbs_string_new(
+      state->string.start + state->current.byte_pos,
+      state->string.end
+    );
     unsigned int c = utf8_to_codepoint(str);
     state->last_char = c;
     return c;

src/parser.c

@@ -113,7 +113,7 @@ static rbs_string_t rbs_parser_peek_current_token(parserstate *state) {
   const char *start = state->lexstate->string.start + rg.start.byte_pos;
   size_t length = rg.end.byte_pos - rg.start.byte_pos;
 
-  return rbs_string_shared_new(start, start + length);
+  return rbs_string_new(start, start + length);
 }
 
 static rbs_constant_id_t rbs_constant_pool_insert_string(rbs_constant_pool_t *self, rbs_string_t string) {
@@ -1552,11 +1552,10 @@ static bool parse_annotation(parserstate *state, rbs_ast_annotation_t **annotati
     state->lexstate->encoding->char_width((const uint8_t *) "%", (size_t) 1) +
     state->lexstate->encoding->char_width((const uint8_t *) "a", (size_t) 1);
 
-  rbs_string_t str = {
-    .start = state->lexstate->string.start + rg.start.byte_pos + offset_bytes,
-    .end = state->lexstate->string.end,
-    .type = RBS_STRING_SHARED,
-  };
+  rbs_string_t str = rbs_string_new(
+    state->lexstate->string.start + rg.start.byte_pos + offset_bytes,
+    state->lexstate->string.end
+  );
   unsigned int open_char = utf8_to_codepoint(str);
 
   unsigned int close_char;

src/parserstate.c

@@ -186,11 +186,10 @@ static rbs_ast_comment_t *parse_comment_lines(parserstate *state, comment *com)
     const char *comment_start = state->lexstate->string.start + tok.range.start.byte_pos + hash_bytes;
     size_t comment_bytes = RANGE_BYTES(tok.range) - hash_bytes;
 
-    rbs_string_t str = {
-      .start = comment_start,
-      .end = state->lexstate->string.end,
-      .type = RBS_STRING_SHARED,
-    };
+    rbs_string_t str = rbs_string_new(
+      comment_start,
+      state->lexstate->string.end
+    );
     unsigned char c = utf8_to_codepoint(str);
 
     if (c == ' ') {

src/rbs_buffer.c

@@ -56,7 +56,7 @@ void rbs_buffer_append_string(rbs_buffer_t *buffer, const char *value, size_t le
 }
 
 rbs_string_t rbs_buffer_to_string(rbs_buffer_t *buffer) {
-    return rbs_string_shared_new(buffer->value, buffer->value + buffer->length);
+    return rbs_string_new(buffer->value, buffer->value + buffer->length);
 }
 
 void rbs_buffer_free(rbs_buffer_t *buffer) {

src/rbs_string.c

@@ -5,19 +5,10 @@
 #include <stdio.h>
 #include <ctype.h>
 
-rbs_string_t rbs_string_shared_new(const char *start, const char *end) {
+rbs_string_t rbs_string_new(const char *start, const char *end) {
     return (rbs_string_t) {
         .start = start,
         .end = end,
-        .type = RBS_STRING_SHARED,
-    };
-}
-
-rbs_string_t rbs_string_owned_new(const char *start, const char *end) {
-    return (rbs_string_t) {
-        .start = start,
-        .end = end,
-        .type = RBS_STRING_OWNED,
     };
 }
 
@@ -26,7 +17,7 @@ rbs_string_t rbs_string_copy_slice(rbs_allocator_t *allocator, rbs_string_t *sel
     strncpy(buffer, self->start + start_inset, length);
     buffer[length] = '\0';
 
-    return rbs_string_owned_new(buffer, buffer + length);
+    return rbs_string_new(buffer, buffer + length);
 }
 
 rbs_string_t rbs_string_strip_whitespace(rbs_allocator_t *allocator, rbs_string_t *self) {
@@ -36,7 +27,7 @@ rbs_string_t rbs_string_strip_whitespace(rbs_allocator_t *allocator, rbs_string_
     }
 
     if (new_start == self->end) { // Handle empty string case
-        return rbs_string_shared_new(new_start, new_start);
+        return rbs_string_new(new_start, new_start);
     }
 
     const char *new_end = self->end - 1;

src/rbs_unescape.c

@@ -103,7 +103,7 @@ rbs_string_t unescape_string(const rbs_string_t string, bool is_double_quote) {
         }
     }
     output[j] = '\0';
-    return rbs_string_owned_new(output, output + j);
+    return rbs_string_new(output, output + j);
 }
 
 rbs_string_t rbs_unquote_string(rbs_allocator_t *allocator, rbs_string_t input) {

templates/src/ast.c.erb

@@ -206,7 +206,6 @@ void rbs_node_destroy(rbs_node_t *any_node) {
         <%- node.fields.each do |field| -%>
         <%- case field.c_type -%>
         <%- when "rbs_string" -%>
-        // <%= field.c_name %> is a string, so it will be freed when the allocator is freed.
         <%- when "rbs_node_list" -%>
         rbs_node_list_free(node-><%= field.c_name %>);
         <%- when "rbs_hash" -%>