prism 0.27.0 → 0.29.0

data/src/serialize.c

@@ -407,8 +407,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             }
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->read_name));
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->write_name));
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->operator));
-            pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->binary_operator));
+            pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->value, buffer);
             break;
         }
@@ -529,9 +529,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_class_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_class_variable_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_class_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_operator_write_node_t *)node)->value, buffer);
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->binary_operator));
             break;
         }
         case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
@@ -566,9 +566,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_CONSTANT_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_constant_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_constant_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_constant_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_operator_write_node_t *)node)->value, buffer);
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->binary_operator));
             break;
         }
         case PM_CONSTANT_OR_WRITE_NODE: {
@@ -590,15 +590,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_node_t *)node)->parent, buffer);
             }
-            pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_node_t *)node)->child, buffer);
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_constant_path_node_t *)node)->delimiter_loc, buffer);
+            pm_serialize_location(parser, &((pm_constant_path_node_t *)node)->name_loc, buffer);
             break;
         }
         case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->target, buffer);
-            pm_serialize_location(parser, &((pm_constant_path_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_constant_path_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->value, buffer);
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_operator_write_node_t *)node)->binary_operator));
             break;
         }
         case PM_CONSTANT_PATH_OR_WRITE_NODE: {
@@ -613,8 +614,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_target_node_t *)node)->parent, buffer);
             }
-            pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_target_node_t *)node)->child, buffer);
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_target_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_constant_path_target_node_t *)node)->delimiter_loc, buffer);
+            pm_serialize_location(parser, &((pm_constant_path_target_node_t *)node)->name_loc, buffer);
             break;
         }
         case PM_CONSTANT_PATH_WRITE_NODE: {
@@ -850,9 +852,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_global_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_global_variable_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_global_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_operator_write_node_t *)node)->value, buffer);
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->binary_operator));
             break;
         }
         case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
@@ -1030,8 +1032,8 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             } else {
                 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->block, buffer);
             }
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_index_operator_write_node_t *)node)->operator));
-            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_index_operator_write_node_t *)node)->binary_operator));
+            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->value, buffer);
             break;
         }
@@ -1091,9 +1093,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_instance_variable_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_instance_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_operator_write_node_t *)node)->value, buffer);
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->binary_operator));
             break;
         }
         case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
@@ -1251,10 +1253,10 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
         }
         case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
             pm_serialize_location(parser, &((pm_local_variable_operator_write_node_t *)node)->name_loc, buffer);
-            pm_serialize_location(parser, &((pm_local_variable_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_location(parser, &((pm_local_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
             pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_operator_write_node_t *)node)->value, buffer);
             pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->name));
-            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->operator));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->binary_operator));
             pm_buffer_append_varuint(buffer, ((pm_local_variable_operator_write_node_t *)node)->depth);
             break;
         }
@@ -1625,6 +1627,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             break;
         }
         case PM_RETURN_NODE: {
+            pm_buffer_append_varuint(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_serialize_location(parser, &((pm_return_node_t *)node)->keyword_loc, buffer);
             if (((pm_return_node_t *)node)->arguments == NULL) {
                 pm_buffer_append_byte(buffer, 0);

data/src/static_literals.c

@@ -1,5 +1,21 @@
 #include "prism/static_literals.h"
 
+/**
+ * A small struct used for passing around a subset of the information that is
+ * stored on the parser. We use this to avoid having static literals explicitly
+ * depend on the parser struct.
+ */
+typedef struct {
+    /** The list of newline offsets to use to calculate line numbers. */
+    const pm_newline_list_t *newline_list;
+
+    /** The line number that the parser starts on. */
+    int32_t start_line;
+
+    /** The name of the encoding that the parser is using. */
+    const char *encoding_name;
+} pm_static_literals_metadata_t;
+
 static inline uint32_t
 murmur_scramble(uint32_t value) {
     value *= 0xcc9e2d51;
@@ -48,7 +64,7 @@ murmur_hash(const uint8_t *key, size_t length) {
  * these hashes to look for duplicates.
  */
 static uint32_t
-node_hash(const pm_parser_t *parser, const pm_node_t *node) {
+node_hash(const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
     switch (PM_NODE_TYPE(node)) {
         case PM_INTEGER_NODE: {
             // Integers hash their value.
@@ -68,7 +84,7 @@ node_hash(const pm_parser_t *parser, const pm_node_t *node) {
         }
         case PM_SOURCE_LINE_NODE: {
             // Source lines hash their line number.
-            const pm_line_column_t line_column = pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line);
+            const pm_line_column_t line_column = pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line);
             const int32_t *value = &line_column.line;
             return murmur_hash((const uint8_t *) value, sizeof(int32_t));
         }
@@ -82,14 +98,14 @@ node_hash(const pm_parser_t *parser, const pm_node_t *node) {
             // is stored as a subnode, we hash that node and then mix in the
             // fact that this is a rational node.
             const pm_node_t *numeric = ((const pm_rational_node_t *) node)->numeric;
-            return node_hash(parser, numeric) ^ murmur_scramble((uint32_t) node->type);
+            return node_hash(metadata, numeric) ^ murmur_scramble((uint32_t) node->type);
         }
         case PM_IMAGINARY_NODE: {
             // Imaginaries hash their numeric value. Because their numeric value
             // is stored as a subnode, we hash that node and then mix in the
             // fact that this is an imaginary node.
             const pm_node_t *numeric = ((const pm_imaginary_node_t *) node)->numeric;
-            return node_hash(parser, numeric) ^ murmur_scramble((uint32_t) node->type);
+            return node_hash(metadata, numeric) ^ murmur_scramble((uint32_t) node->type);
         }
         case PM_STRING_NODE: {
             // Strings hash their value and mix in their flags so that different
@@ -132,7 +148,7 @@ node_hash(const pm_parser_t *parser, const pm_node_t *node) {
  * and must be able to compare all node types that will be stored in this hash.
  */
 static pm_node_t *
-pm_node_hash_insert(pm_node_hash_t *hash, const pm_parser_t *parser, pm_node_t *node, int (*compare)(const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right)) {
+pm_node_hash_insert(pm_node_hash_t *hash, const pm_static_literals_metadata_t *metadata, pm_node_t *node, int (*compare)(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right)) {
     // If we are out of space, we need to resize the hash. This will cause all
     // of the nodes to be rehashed and reinserted into the new hash.
     if (hash->size * 2 >= hash->capacity) {
@@ -152,7 +168,7 @@ pm_node_hash_insert(pm_node_hash_t *hash, const pm_parser_t *parser, pm_node_t *
             pm_node_t *node = hash->nodes[index];
 
             if (node != NULL) {
-                uint32_t index = node_hash(parser, node) & mask;
+                uint32_t index = node_hash(metadata, node) & mask;
                 new_nodes[index] = node;
             }
         }
@@ -165,14 +181,14 @@ pm_node_hash_insert(pm_node_hash_t *hash, const pm_parser_t *parser, pm_node_t *
 
     // Now, insert the node into the hash.
     uint32_t mask = hash->capacity - 1;
-    uint32_t index = node_hash(parser, node) & mask;
+    uint32_t index = node_hash(metadata, node) & mask;
 
     // We use linear probing to resolve collisions. This means that if the
     // current index is occupied, we will move to the next index and try again.
     // We are guaranteed that this will eventually find an empty slot because we
     // resize the hash when it gets too full.
     while (hash->nodes[index] != NULL) {
-        if (compare(parser, hash->nodes[index], node) == 0) break;
+        if (compare(metadata, hash->nodes[index], node) == 0) break;
         index = (index + 1) & mask;
     }
 
@@ -203,7 +219,7 @@ pm_node_hash_free(pm_node_hash_t *hash) {
  * Return the integer value of the given node as an int64_t.
  */
 static int64_t
-pm_int64_value(const pm_parser_t *parser, const pm_node_t *node) {
+pm_int64_value(const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
     switch (PM_NODE_TYPE(node)) {
         case PM_INTEGER_NODE: {
             const pm_integer_t *integer = &((const pm_integer_node_t *) node)->value;
@@ -213,7 +229,7 @@ pm_int64_value(const pm_parser_t *parser, const pm_node_t *node) {
             return integer->negative ? -value : value;
         }
         case PM_SOURCE_LINE_NODE:
-            return (int64_t) pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line;
+            return (int64_t) pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line).line;
         default:
             assert(false && "unreachable");
             return 0;
@@ -225,10 +241,10 @@ pm_int64_value(const pm_parser_t *parser, const pm_node_t *node) {
  * instances.
  */
 static int
-pm_compare_integer_nodes(const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right) {
+pm_compare_integer_nodes(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
     if (PM_NODE_TYPE_P(left, PM_SOURCE_LINE_NODE) || PM_NODE_TYPE_P(right, PM_SOURCE_LINE_NODE)) {
-        int64_t left_value = pm_int64_value(parser, left);
-        int64_t right_value = pm_int64_value(parser, right);
+        int64_t left_value = pm_int64_value(metadata, left);
+        int64_t right_value = pm_int64_value(metadata, right);
         return PM_NUMERIC_COMPARISON(left_value, right_value);
     }
 
@@ -241,7 +257,7 @@ pm_compare_integer_nodes(const pm_parser_t *parser, const pm_node_t *left, const
  * A comparison function for comparing two FloatNode instances.
  */
 static int
-pm_compare_float_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right) {
+pm_compare_float_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
     const double left_value = ((const pm_float_node_t *) left)->value;
     const double right_value = ((const pm_float_node_t *) right)->value;
     return PM_NUMERIC_COMPARISON(left_value, right_value);
@@ -251,20 +267,20 @@ pm_compare_float_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *parser, const p
  * A comparison function for comparing two nodes that have attached numbers.
  */
 static int
-pm_compare_number_nodes(const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right) {
+pm_compare_number_nodes(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
     if (PM_NODE_TYPE(left) != PM_NODE_TYPE(right)) {
         return PM_NUMERIC_COMPARISON(PM_NODE_TYPE(left), PM_NODE_TYPE(right));
     }
 
     switch (PM_NODE_TYPE(left)) {
         case PM_IMAGINARY_NODE:
-            return pm_compare_number_nodes(parser, ((const pm_imaginary_node_t *) left)->numeric, ((const pm_imaginary_node_t *) right)->numeric);
+            return pm_compare_number_nodes(metadata, ((const pm_imaginary_node_t *) left)->numeric, ((const pm_imaginary_node_t *) right)->numeric);
         case PM_RATIONAL_NODE:
-            return pm_compare_number_nodes(parser, ((const pm_rational_node_t *) left)->numeric, ((const pm_rational_node_t *) right)->numeric);
+            return pm_compare_number_nodes(metadata, ((const pm_rational_node_t *) left)->numeric, ((const pm_rational_node_t *) right)->numeric);
         case PM_INTEGER_NODE:
-            return pm_compare_integer_nodes(parser, left, right);
+            return pm_compare_integer_nodes(metadata, left, right);
         case PM_FLOAT_NODE:
-            return pm_compare_float_nodes(parser, left, right);
+            return pm_compare_float_nodes(metadata, left, right);
         default:
             assert(false && "unreachable");
             return 0;
@@ -293,7 +309,7 @@ pm_string_value(const pm_node_t *node) {
  * A comparison function for comparing two nodes that have attached strings.
  */
 static int
-pm_compare_string_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right) {
+pm_compare_string_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
     const pm_string_t *left_string = pm_string_value(left);
     const pm_string_t *right_string = pm_string_value(right);
     return pm_string_compare(left_string, right_string);
@@ -303,7 +319,7 @@ pm_compare_string_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *parser, const
  * A comparison function for comparing two RegularExpressionNode instances.
  */
 static int
-pm_compare_regular_expression_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *parser, const pm_node_t *left, const pm_node_t *right) {
+pm_compare_regular_expression_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
     const pm_regular_expression_node_t *left_regexp = (const pm_regular_expression_node_t *) left;
     const pm_regular_expression_node_t *right_regexp = (const pm_regular_expression_node_t *) right;
 
@@ -319,23 +335,77 @@ pm_compare_regular_expression_nodes(PRISM_ATTRIBUTE_UNUSED const pm_parser_t *pa
  * Add a node to the set of static literals.
  */
 pm_node_t *
-pm_static_literals_add(const pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node) {
+pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node) {
     switch (PM_NODE_TYPE(node)) {
         case PM_INTEGER_NODE:
         case PM_SOURCE_LINE_NODE:
-            return pm_node_hash_insert(&literals->integer_nodes, parser, node, pm_compare_integer_nodes);
+            return pm_node_hash_insert(
+                &literals->integer_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_integer_nodes
+            );
         case PM_FLOAT_NODE:
-            return pm_node_hash_insert(&literals->float_nodes, parser, node, pm_compare_float_nodes);
+            return pm_node_hash_insert(
+                &literals->float_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_float_nodes
+            );
         case PM_RATIONAL_NODE:
         case PM_IMAGINARY_NODE:
-            return pm_node_hash_insert(&literals->number_nodes, parser, node, pm_compare_number_nodes);
+            return pm_node_hash_insert(
+                &literals->number_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_number_nodes
+            );
         case PM_STRING_NODE:
         case PM_SOURCE_FILE_NODE:
-            return pm_node_hash_insert(&literals->string_nodes, parser, node, pm_compare_string_nodes);
+            return pm_node_hash_insert(
+                &literals->string_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_string_nodes
+            );
         case PM_REGULAR_EXPRESSION_NODE:
-            return pm_node_hash_insert(&literals->regexp_nodes, parser, node, pm_compare_regular_expression_nodes);
+            return pm_node_hash_insert(
+                &literals->regexp_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_regular_expression_nodes
+            );
         case PM_SYMBOL_NODE:
-            return pm_node_hash_insert(&literals->symbol_nodes, parser, node, pm_compare_string_nodes);
+            return pm_node_hash_insert(
+                &literals->symbol_nodes,
+                &(pm_static_literals_metadata_t) {
+                    .newline_list = newline_list,
+                    .start_line = start_line,
+                    .encoding_name = NULL
+                },
+                node,
+                pm_compare_string_nodes
+            );
         case PM_TRUE_NODE: {
             pm_node_t *duplicated = literals->true_node;
             literals->true_node = node;
@@ -435,8 +505,8 @@ pm_rational_inspect(pm_buffer_t *buffer, pm_rational_node_t *node) {
 /**
  * Create a string-based representation of the given static literal.
  */
-PRISM_EXPORTED_FUNCTION void
-pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node) {
+static inline void
+pm_static_literal_inspect_node(pm_buffer_t *buffer, const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
     switch (PM_NODE_TYPE(node)) {
         case PM_FALSE_NODE:
             pm_buffer_append_string(buffer, "false", 5);
@@ -473,7 +543,7 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const
             const pm_node_t *numeric = ((const pm_imaginary_node_t *) node)->numeric;
             pm_buffer_append_string(buffer, "(0", 2);
             if (pm_static_literal_positive_p(numeric)) pm_buffer_append_byte(buffer, '+');
-            pm_static_literal_inspect(buffer, parser, numeric);
+            pm_static_literal_inspect_node(buffer, metadata, numeric);
             if (PM_NODE_TYPE_P(numeric, PM_RATIONAL_NODE)) pm_buffer_append_byte(buffer, '*');
             pm_buffer_append_string(buffer, "i)", 2);
             break;
@@ -490,7 +560,7 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const
             switch (PM_NODE_TYPE(numeric)) {
                 case PM_INTEGER_NODE:
                     pm_buffer_append_byte(buffer, '(');
-                    pm_static_literal_inspect(buffer, parser, numeric);
+                    pm_static_literal_inspect_node(buffer, metadata, numeric);
                     pm_buffer_append_string(buffer, "/1)", 3);
                     break;
                 case PM_FLOAT_NODE:
@@ -517,7 +587,7 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const
             break;
         }
         case PM_SOURCE_ENCODING_NODE:
-            pm_buffer_append_format(buffer, "#<Encoding:%s>", parser->encoding->name);
+            pm_buffer_append_format(buffer, "#<Encoding:%s>", metadata->encoding_name);
             break;
         case PM_SOURCE_FILE_NODE: {
             const pm_string_t *filepath = &((const pm_source_file_node_t *) node)->filepath;
@@ -527,7 +597,7 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const
             break;
         }
         case PM_SOURCE_LINE_NODE:
-            pm_buffer_append_format(buffer, "%d", pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line);
+            pm_buffer_append_format(buffer, "%d", pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line).line);
             break;
         case PM_STRING_NODE: {
             const pm_string_t *unescaped = &((const pm_string_node_t *) node)->unescaped;
@@ -550,3 +620,19 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const
             break;
     }
 }
+
+/**
+ * Create a string-based representation of the given static literal.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node) {
+    pm_static_literal_inspect_node(
+        buffer,
+        &(pm_static_literals_metadata_t) {
+            .newline_list = newline_list,
+            .start_line = start_line,
+            .encoding_name = encoding_name
+        },
+        node
+    );
+}

data/src/token_type.c

@@ -422,9 +422,9 @@ pm_token_type_human(pm_token_type_t token_type) {
         case PM_TOKEN_DOT:
             return "'.'";
         case PM_TOKEN_DOT_DOT:
-            return "'..'";
+            return "..";
         case PM_TOKEN_DOT_DOT_DOT:
-            return "'...'";
+            return "...";
         case PM_TOKEN_EMBDOC_BEGIN:
             return "'=begin'";
         case PM_TOKEN_EMBDOC_END:
@@ -462,9 +462,9 @@ pm_token_type_human(pm_token_type_t token_type) {
         case PM_TOKEN_GREATER_EQUAL:
             return "'>='";
         case PM_TOKEN_GREATER_GREATER:
-            return "'>>'";
+            return ">>";
         case PM_TOKEN_GREATER_GREATER_EQUAL:
-            return "'>>='";
+            return ">>=";
         case PM_TOKEN_HEREDOC_END:
             return "heredoc ending";
         case PM_TOKEN_HEREDOC_START:
@@ -590,9 +590,9 @@ pm_token_type_human(pm_token_type_t token_type) {
         case PM_TOKEN_LESS_EQUAL_GREATER:
             return "'<=>'";
         case PM_TOKEN_LESS_LESS:
-            return "'<<'";
+            return "<<";
         case PM_TOKEN_LESS_LESS_EQUAL:
-            return "'<<='";
+            return "<<=";
         case PM_TOKEN_METHOD_NAME:
             return "method name";
         case PM_TOKEN_MINUS:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prism
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.29.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-05-10 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -81,17 +81,18 @@ files:
 - lib/prism/dot_visitor.rb
 - lib/prism/dsl.rb
 - lib/prism/ffi.rb
+- lib/prism/inspect_visitor.rb
 - lib/prism/lex_compat.rb
 - lib/prism/mutation_compiler.rb
 - lib/prism/node.rb
 - lib/prism/node_ext.rb
-- lib/prism/node_inspector.rb
 - lib/prism/pack.rb
 - lib/prism/parse_result.rb
 - lib/prism/parse_result/comments.rb
 - lib/prism/parse_result/newlines.rb
 - lib/prism/pattern.rb
-- lib/prism/polyfill/string.rb
+- lib/prism/polyfill/byteindex.rb
+- lib/prism/polyfill/unpack1.rb
 - lib/prism/reflection.rb
 - lib/prism/serialize.rb
 - lib/prism/translation.rb
@@ -109,25 +110,23 @@ files:
 - prism.gemspec
 - rbi/prism.rbi
 - rbi/prism/compiler.rbi
-- rbi/prism/desugar_compiler.rbi
-- rbi/prism/mutation_compiler.rbi
+- rbi/prism/inspect_visitor.rbi
 - rbi/prism/node.rbi
 - rbi/prism/node_ext.rbi
 - rbi/prism/parse_result.rbi
 - rbi/prism/reflection.rbi
 - rbi/prism/translation/parser.rbi
-- rbi/prism/translation/parser/compiler.rbi
 - rbi/prism/translation/parser33.rbi
 - rbi/prism/translation/parser34.rbi
 - rbi/prism/translation/ripper.rbi
-- rbi/prism/translation/ripper/ripper_compiler.rbi
-- rbi/prism/translation/ruby_parser.rbi
 - rbi/prism/visitor.rbi
 - sig/prism.rbs
 - sig/prism/compiler.rbs
 - sig/prism/dispatcher.rbs
 - sig/prism/dot_visitor.rbs
 - sig/prism/dsl.rbs
+- sig/prism/inspect_visitor.rbs
+- sig/prism/lex_compat.rbs
 - sig/prism/mutation_compiler.rbs
 - sig/prism/node.rbs
 - sig/prism/node_ext.rbs

data/lib/prism/node_inspector.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Prism
-  # This object is responsible for generating the output for the inspect method
-  # implementations of child nodes.
-  class NodeInspector # :nodoc:
-    attr_reader :prefix, :output
-
-    def initialize(prefix = "")
-      @prefix = prefix
-      @output = +""
-    end
-
-    # Appends a line to the output with the current prefix.
-    def <<(line)
-      output << "#{prefix}#{line}"
-    end
-
-    # This generates a string that is used as the header of the inspect output
-    # for any given node.
-    def header(node)
-      output = +"@ #{node.class.name.split("::").last} ("
-      output << "location: (#{node.location.start_line},#{node.location.start_column})-(#{node.location.end_line},#{node.location.end_column})"
-      output << ", newline: true" if node.newline?
-      output << ")\n"
-      output
-    end
-
-    # Generates a string that represents a list of nodes. It handles properly
-    # using the box drawing characters to make the output look nice.
-    def list(prefix, nodes)
-      output = +"(length: #{nodes.length})\n"
-      last_index = nodes.length - 1
-
-      nodes.each_with_index do |node, index|
-        pointer, preadd = (index == last_index) ? ["└── ", "    "] : ["├── ", "│   "]
-        node_prefix = "#{prefix}#{preadd}"
-        output << node.inspect(NodeInspector.new(node_prefix)).sub(node_prefix, "#{prefix}#{pointer}")
-      end
-
-      output
-    end
-
-    # Generates a string that represents a location field on a node.
-    def location(value)
-      if value
-        "(#{value.start_line},#{value.start_column})-(#{value.end_line},#{value.end_column}) = #{value.slice.inspect}"
-      else
-        "∅"
-      end
-    end
-
-    # Generates a string that represents a child node.
-    def child_node(node, append)
-      node.inspect(child_inspector(append)).delete_prefix(prefix)
-    end
-
-    # Returns a new inspector that can be used to inspect a child node.
-    def child_inspector(append)
-      NodeInspector.new("#{prefix}#{append}")
-    end
-
-    # Returns the output as a string.
-    def to_str
-      output
-    end
-  end
-end

data/lib/prism/polyfill/string.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# Polyfill for String#unpack1 with the offset parameter.
-if String.instance_method(:unpack1).parameters.none? { |_, name| name == :offset }
-  String.prepend(
-    Module.new {
-      def unpack1(format, offset: 0) # :nodoc:
-        offset == 0 ? super(format) : self[offset..].unpack1(format) # steep:ignore
-      end
-    }
-  )
-end

data/rbi/prism/desugar_compiler.rbi

@@ -1,5 +0,0 @@
-# typed: strict
-
-class Prism::DesugarCompiler < Prism::MutationCompiler
-  Result = type_member { { fixed: Prism::Node } }
-end

data/rbi/prism/mutation_compiler.rbi

@@ -1,5 +0,0 @@
-# typed: strict
-
-class Prism::MutationCompiler < Prism::Compiler
-  Result = type_member
-end

data/rbi/prism/translation/parser/compiler.rbi

@@ -1,13 +0,0 @@
-# typed: strict
-
-# We keep these shims in here because our client libraries might not have
-# ast/parser in their bundle.
-module AST; end
-class AST::Node; end
-module Parser; end
-module Parser::AST; end
-class Parser::AST::Node < AST::Node; end
-
-class Prism::Translation::Parser::Compiler < Prism::Compiler
-  Result = type_member { { fixed: Parser::AST::Node } }
-end