[ruby/prism] Rename varint as varuint

Line numbers may be negative, so we need to introduce signed varint,
so renaming unsigned ones first avoid confusion.

https://github.com/ruby/prism/commit/90d862361e

5 files changed, 58 insertions, 58 deletions

diff --git a/prism/prism.c b/prism/prism.c
index 41ed44e9c1..aee9fc7b88 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -17268,7 +17268,7 @@ pm_serialize_parse_comments(pm_buffer_t *buffer, const uint8_t *source, size_t s
     pm_node_t *node = pm_parse(&parser);
     pm_serialize_header(buffer);
     pm_serialize_encoding(&parser.encoding, buffer);
-    pm_buffer_append_varint(buffer, parser.start_line);
+    pm_buffer_append_varuint(buffer, parser.start_line);
     pm_serialize_comment_list(&parser, &parser.comment_list, buffer);
 
     pm_node_destroy(&parser, node);
diff --git a/prism/templates/lib/prism/serialize.rb.erb b/prism/templates/lib/prism/serialize.rb.erb
index 681b6117b4..a38c796971 100644
--- a/prism/templates/lib/prism/serialize.rb.erb
+++ b/prism/templates/lib/prism/serialize.rb.erb
@@ -73,18 +73,18 @@ module Prism
       end
 
       def load_encoding
-        @encoding = Encoding.find(io.read(load_varint))
+        @encoding = Encoding.find(io.read(load_varuint))
         @input = input.force_encoding(@encoding).freeze
         @encoding
       end
 
       def load_start_line
-        source.start_line = load_varint
+        source.start_line = load_varuint
       end
 
       def load_comments
-        load_varint.times.map do
-          case load_varint
+        load_varuint.times.map do
+          case load_varuint
           when 0 then InlineComment.new(load_location)
           when 1 then EmbDocComment.new(load_location)
           when 2 then DATAComment.new(load_location)
@@ -94,19 +94,19 @@ module Prism
 
       def load_metadata
         comments = load_comments
-        magic_comments = load_varint.times.map { MagicComment.new(load_location, load_location) }
+        magic_comments = load_varuint.times.map { MagicComment.new(load_location, load_location) }
         data_loc = load_optional_location
-        errors = load_varint.times.map { ParseError.new(load_embedded_string, load_location) }
-        warnings = load_varint.times.map { ParseWarning.new(load_embedded_string, load_location) }
+        errors = load_varuint.times.map { ParseError.new(load_embedded_string, load_location) }
+        warnings = load_varuint.times.map { ParseWarning.new(load_embedded_string, load_location) }
         [comments, magic_comments, data_loc, errors, warnings]
       end
 
       def load_tokens
         tokens = []
-        while type = TOKEN_TYPES.fetch(load_varint)
-          start = load_varint
-          length = load_varint
-          lex_state = load_varint
+        while type = TOKEN_TYPES.fetch(load_varuint)
+          start = load_varuint
+          length = load_varuint
+          lex_state = load_varuint
           location = Location.new(@source, start, length)
           tokens << [Prism::Token.new(type, location.slice, location), lex_state]
         end
@@ -133,7 +133,7 @@ module Prism
         comments, magic_comments, data_loc, errors, warnings = load_metadata
 
         @constant_pool_offset = io.read(4).unpack1("L")
-        @constant_pool = Array.new(load_varint, nil)
+        @constant_pool = Array.new(load_varuint, nil)
 
         [load_node, comments, magic_comments, data_loc, errors, warnings]
       end
@@ -147,7 +147,7 @@ module Prism
 
       # variable-length integer using https://en.wikipedia.org/wiki/LEB128
       # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
-      def load_varint
+      def load_varuint
         n = io.getbyte
         if n < 128
           n
@@ -173,14 +173,14 @@ module Prism
       end
 
       def load_embedded_string
-        io.read(load_varint).force_encoding(encoding)
+        io.read(load_varuint).force_encoding(encoding)
       end
 
       def load_string
         type = io.getbyte
         case type
         when 1
-          input.byteslice(load_varint, load_varint).force_encoding(encoding)
+          input.byteslice(load_varuint, load_varuint).force_encoding(encoding)
         when 2
           load_embedded_string
         else
@@ -189,7 +189,7 @@ module Prism
       end
 
       def load_location
-        Location.new(source, load_varint, load_varint)
+        Location.new(source, load_varuint, load_varuint)
       end
 
       def load_optional_location
@@ -218,11 +218,11 @@ module Prism
       end
 
       def load_required_constant
-        load_constant(load_varint - 1)
+        load_constant(load_varuint - 1)
       end
 
       def load_optional_constant
-        index = load_varint
+        index = load_varuint
         load_constant(index - 1) if index != 0
       end
 
@@ -242,13 +242,13 @@ module Prism
               when Prism::NodeField then "load_node"
               when Prism::OptionalNodeField then "load_optional_node"
               when Prism::StringField then "load_string"
-              when Prism::NodeListField then "Array.new(load_varint) { load_node }"
+              when Prism::NodeListField then "Array.new(load_varuint) { load_node }"
               when Prism::ConstantField then "load_required_constant"
               when Prism::OptionalConstantField then "load_optional_constant"
-              when Prism::ConstantListField then "Array.new(load_varint) { load_required_constant }"
+              when Prism::ConstantListField then "Array.new(load_varuint) { load_required_constant }"
               when Prism::LocationField then "load_location"
               when Prism::OptionalLocationField then "load_optional_location"
-              when Prism::UInt32Field, Prism::FlagsField then "load_varint"
+              when Prism::UInt32Field, Prism::FlagsField then "load_varuint"
               else raise
               end
             } + ["location"]).join(", ") -%>)
@@ -275,13 +275,13 @@ module Prism
                 when Prism::NodeField then "load_node"
                 when Prism::OptionalNodeField then "load_optional_node"
                 when Prism::StringField then "load_string"
-                when Prism::NodeListField then "Array.new(load_varint) { load_node }"
+                when Prism::NodeListField then "Array.new(load_varuint) { load_node }"
                 when Prism::ConstantField then "load_required_constant"
                 when Prism::OptionalConstantField then "load_optional_constant"
-                when Prism::ConstantListField then "Array.new(load_varint) { load_required_constant }"
+                when Prism::ConstantListField then "Array.new(load_varuint) { load_required_constant }"
                 when Prism::LocationField then "load_location"
                 when Prism::OptionalLocationField then "load_optional_location"
-                when Prism::UInt32Field, Prism::FlagsField then "load_varint"
+                when Prism::UInt32Field, Prism::FlagsField then "load_varuint"
                 else raise
                 end
               } + ["location"]).join(", ") -%>)
diff --git a/prism/templates/src/serialize.c.erb b/prism/templates/src/serialize.c.erb
index 0ea70a3976..0f6b119d5b 100644
--- a/prism/templates/src/serialize.c.erb
+++ b/prism/templates/src/serialize.c.erb
@@ -20,8 +20,8 @@ pm_serialize_location(const pm_parser_t *parser, const pm_location_t *location,
     assert(location->end);
     assert(location->start <= location->end);
 
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(location->start - parser->start));
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(location->end - location->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->end - location->start));
 }
 
 static void
@@ -29,15 +29,15 @@ pm_serialize_string(pm_parser_t *parser, pm_string_t *string, pm_buffer_t *buffe
     switch (string->type) {
         case PM_STRING_SHARED: {
             pm_buffer_append_byte(buffer, 1);
-            pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
-            pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_string_length(string)));
+            pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(string)));
             break;
         }
         case PM_STRING_OWNED:
         case PM_STRING_CONSTANT: {
             uint32_t length = pm_sizet_to_u32(pm_string_length(string));
             pm_buffer_append_byte(buffer, 2);
-            pm_buffer_append_varint(buffer, length);
+            pm_buffer_append_varuint(buffer, length);
             pm_buffer_append_bytes(buffer, pm_string_source(string), length);
             break;
         }
@@ -82,17 +82,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             pm_serialize_string(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
             <%- when Prism::NodeListField -%>
             uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
-            pm_buffer_append_varint(buffer, <%= field.name %>_size);
+            pm_buffer_append_varuint(buffer, <%= field.name %>_size);
             for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
                 pm_serialize_node(parser, (pm_node_t *) ((pm_<%= node.human %>_t *)node)-><%= field.name %>.nodes[index], buffer);
             }
             <%- when Prism::ConstantField, Prism::OptionalConstantField -%>
-            pm_buffer_append_varint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>));
+            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>));
             <%- when Prism::ConstantListField -%>
             uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
-            pm_buffer_append_varint(buffer, <%= field.name %>_size);
+            pm_buffer_append_varuint(buffer, <%= field.name %>_size);
             for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
-                pm_buffer_append_varint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index]));
+                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index]));
             }
             <%- when Prism::LocationField -%>
             <%- if field.should_be_serialized? -%>
@@ -108,9 +108,9 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             }
             <%- end -%>
             <%- when Prism::UInt32Field -%>
-            pm_buffer_append_varint(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
+            pm_buffer_append_varuint(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
             <%- when Prism::FlagsField -%>
-            pm_buffer_append_varint(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
+            pm_buffer_append_varuint(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             <%- else -%>
             <%- raise -%>
             <%- end -%>
@@ -132,8 +132,8 @@ pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *bu
     pm_buffer_append_byte(buffer, (uint8_t) comment->type);
 
     // serialize location
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(comment->start - parser->start));
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(comment->end - comment->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(comment->start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(comment->end - comment->start));
 }
 
 /**
@@ -141,7 +141,7 @@ pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *bu
  */
 void
 pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
     pm_comment_t *comment;
     for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
@@ -152,17 +152,17 @@ pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buf
 static void
 pm_serialize_magic_comment(pm_parser_t *parser, pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
     // serialize key location
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start));
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(magic_comment->key_length));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->key_length));
 
     // serialize value location
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start));
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(magic_comment->value_length));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->value_length));
 }
 
 static void
 pm_serialize_magic_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
     pm_magic_comment_t *magic_comment;
     for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
@@ -184,17 +184,17 @@ static void
 pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
     // serialize message
     size_t message_length = strlen(diagnostic->message);
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(message_length));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
     pm_buffer_append_string(buffer, diagnostic->message, message_length);
 
     // serialize location
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(diagnostic->start - parser->start));
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(diagnostic->end - diagnostic->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(diagnostic->start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(diagnostic->end - diagnostic->start));
 }
 
 static void
 pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
 
     pm_diagnostic_t *diagnostic;
     for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
@@ -208,7 +208,7 @@ pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *
 void
 pm_serialize_encoding(pm_encoding_t *encoding, pm_buffer_t *buffer) {
     size_t encoding_length = strlen(encoding->name);
-    pm_buffer_append_varint(buffer, pm_sizet_to_u32(encoding_length));
+    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
     pm_buffer_append_string(buffer, encoding->name, encoding_length);
 }
 
@@ -219,7 +219,7 @@ pm_serialize_encoding(pm_encoding_t *encoding, pm_buffer_t *buffer) {
 void
 pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
     pm_serialize_encoding(&parser->encoding, buffer);
-    pm_buffer_append_varint(buffer, parser->start_line);
+    pm_buffer_append_varuint(buffer, parser->start_line);
 <%- unless Prism::SERIALIZE_ONLY_SEMANTICS_FIELDS -%>
     pm_serialize_comment_list(parser, &parser->comment_list, buffer);
 <%- end -%>
@@ -234,7 +234,7 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
     pm_buffer_append_zeroes(buffer, 4);
 
     // Next, encode the length of the constant pool.
-    pm_buffer_append_varint(buffer, parser->constant_pool.size);
+    pm_buffer_append_varuint(buffer, parser->constant_pool.size);
 
     // Now we're going to serialize the content of the node.
     pm_serialize_node(parser, node, buffer);
@@ -289,10 +289,10 @@ static void
 serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
     pm_buffer_t *buffer = (pm_buffer_t *) data;
 
-    pm_buffer_append_varint(buffer, token->type);
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
-    pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
-    pm_buffer_append_varint(buffer, parser->lex_state);
+    pm_buffer_append_varuint(buffer, token->type);
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
+    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
+    pm_buffer_append_varuint(buffer, parser->lex_state);
 }
 
 /**
@@ -318,7 +318,7 @@ pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const
     pm_buffer_append_byte(buffer, 0);
 
     pm_serialize_encoding(&parser.encoding, buffer);
-    pm_buffer_append_varint(buffer, parser.start_line);
+    pm_buffer_append_varuint(buffer, parser.start_line);
     pm_serialize_comment_list(&parser, &parser.comment_list, buffer);
     pm_serialize_magic_comment_list(&parser, &parser.magic_comment_list, buffer);
     pm_serialize_data_loc(&parser, buffer);
diff --git a/prism/util/pm_buffer.c b/prism/util/pm_buffer.c
index acc6cad725..dcdf1770bb 100644
--- a/prism/util/pm_buffer.c
+++ b/prism/util/pm_buffer.c
@@ -138,7 +138,7 @@ pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value) {
  * Append a 32-bit unsigned integer to the buffer as a variable-length integer.
  */
 void
-pm_buffer_append_varint(pm_buffer_t *buffer, uint32_t value) {
+pm_buffer_append_varuint(pm_buffer_t *buffer, uint32_t value) {
     if (value < 128) {
         pm_buffer_append_byte(buffer, (uint8_t) value);
     } else {
diff --git a/prism/util/pm_buffer.h b/prism/util/pm_buffer.h
index 3c3a6fb688..a8596be476 100644
--- a/prism/util/pm_buffer.h
+++ b/prism/util/pm_buffer.h
@@ -118,7 +118,7 @@ void pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value);
  * @param buffer The buffer to append to.
  * @param value The integer to append.
  */
-void pm_buffer_append_varint(pm_buffer_t *buffer, uint32_t value);
+void pm_buffer_append_varuint(pm_buffer_t *buffer, uint32_t value);
 
 /**
  * Concatenate one buffer onto another.