Convert character offset to byte offset in parse_inline_*_annotation

Parser.parse_inline_leading_annotation and parse_inline_trailing_annotation
were passing character offsets directly to the C parser, which expects byte
offsets since #2863. With ASCII-only input the two coincide so the bug was
hidden, but multibyte content (e.g. a Japanese comment preceding the
annotation) caused the C parser to start at an invalid byte position and
emit a parsing error.

Apply the existing byte_range helper to convert character offsets to byte
offsets, matching the pattern used by parse_type, parse_method_type, and
other parse_* methods.

The existing tests for parse_inline_*_annotation used ASCII-only input
which would not catch this class of bug, so multibyte regression tests are
added.

Author: pjocprac

lib/rbs/parser_aux.rb

@@ -121,12 +121,14 @@ def self.buffer(source)
 
     def self.parse_inline_leading_annotation(source, range, variables: [])
       buf = buffer(source)
-      _parse_inline_leading_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+      byte_range = byte_range(range, buf.content)
+      _parse_inline_leading_annotation(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables)
     end
 
     def self.parse_inline_trailing_annotation(source, range, variables: [])
       buf = buffer(source)
-      _parse_inline_trailing_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+      byte_range = byte_range(range, buf.content)
+      _parse_inline_trailing_annotation(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables)
     end
 
     def self.byte_range(char_range, content)

test/rbs/inline_annotation_parsing_test.rb

@@ -559,4 +559,37 @@ def test_error__module_self
       Parser.parse_inline_leading_annotation("@rbs module-self: foo", 0...)
     end
   end
+
+  # The annotation starts after multibyte content, so the character offset
+  # and byte offset diverge. The parser receives a character offset and must
+  # convert it to a byte offset internally before passing to the C parser.
+  # Both start_offset and end_offset should be converted; this test uses an
+  # explicit end_offset to exercise both conversions.
+  def test_parse__trailing_assertion__multibyte_offset
+    buffer = Buffer.new(name: Pathname("test.rb"), content: "日本語\n: String")
+
+    Parser.parse_inline_trailing_annotation(buffer, 4...12).tap do |annot|
+      assert_instance_of AST::Ruby::Annotations::NodeTypeAssertion, annot
+      assert_equal ": String", annot.location.source
+      assert_equal ":", annot.prefix_location.source
+      assert_equal "String", annot.type.location.source
+    end
+  end
+
+  # Multibyte both BEFORE the annotation (in the preceding doc comment) and
+  # INSIDE the annotation (in the `-- ` description). Sub-locations
+  # (return, colon, return_type, comment) are all asserted to verify the
+  # parser correctly resolves byte offsets for every location.
+  def test_parse__leading_annotation__multibyte_offset
+    buffer = Buffer.new(name: Pathname("test.rb"), content: "日本語のコメント\n@rbs return: String -- 戻り値の説明")
+
+    Parser.parse_inline_leading_annotation(buffer, 9...).tap do |annot|
+      assert_instance_of AST::Ruby::Annotations::ReturnTypeAnnotation, annot
+      assert_equal "@rbs return: String -- 戻り値の説明", annot.location.source
+      assert_equal "return", annot.return_location.source
+      assert_equal ":", annot.colon_location.source
+      assert_equal "String", annot.return_type.location.source
+      assert_equal "-- 戻り値の説明", annot.comment_location.source
+    end
+  end
 end