Stop the lexer reading past the end of a byte_range

`rbs_next_char` ends the input when `byte_pos == end_pos`. `rbs_skip`
advances by a whole character, so a multibyte character starting before
`end_pos` and ending after it steps over the boundary and equality never
holds again — the lexer then reads to the end of the string.

    Parser.parse_type('"Ωx" | Integer', byte_range: 0...2)
    #=> Types::Union spanning 0...14, the whole input

Two bytes were requested and fourteen were read, and `require_eof: true`
does not catch it because the lexer really is at EOF by then. It needs a
character to straddle the boundary, so ASCII-only input never hits it.

Compare with `>=` so stepping over the boundary still ends the input.

Author: ksss

src/lexstate.c

@@ -119,7 +119,9 @@ unsigned int rbs_peek(rbs_lexer_t *lexer) {
 }
 
 bool rbs_next_char(rbs_lexer_t *lexer, unsigned int *codepoint, size_t *byte_len) {
-    if (RBS_UNLIKELY(lexer->current.byte_pos == lexer->end_pos)) {
+    // `>=`, not `==`: a character straddling `end_pos` moves `byte_pos` past it
+    // in one step, and equality would never hold again.
+    if (RBS_UNLIKELY(lexer->current.byte_pos >= lexer->end_pos)) {
         return false;
     }
 
@@ -132,7 +134,8 @@ bool rbs_next_char(rbs_lexer_t *lexer, unsigned int *codepoint, size_t *byte_len
         return true;
     }
 
-    *byte_len = lexer->encoding->char_width((const uint8_t *) start, (ptrdiff_t) (lexer->string.end - start));
+    ptrdiff_t remaining = (ptrdiff_t) (lexer->string.end - start);
+    *byte_len = lexer->encoding->char_width((const uint8_t *) start, remaining);
 
     if (*byte_len == 0) {
         // Invalid byte under the active encoding. Map it to a sentinel code

test/rbs/type_parsing_test.rb

@@ -1029,4 +1029,24 @@ def test_parse__byte_range_incorrect
 
     assert_equal "a.rbs:1:2...1:3: Syntax error: unexpected token for simple type, token=`🐈` (ErrorToken)", exn.message
   end
+
+  def test_parse__byte_range_ending_mid_character
+    # `Ω` is two bytes, so this range ends inside it. Advancing by a whole
+    # character stepped over `end_pos`, after which the EOF test never held
+    # again and the rest of the string was read.
+    assert_raises RBS::ParsingError do
+      Parser.parse_type('"Ωx" | Integer', byte_range: 0...2)
+    end
+
+    # A range ending on a character boundary is unaffected.
+    Parser.parse_type('"Ωx" | Integer', byte_range: 0...5, require_eof: true).tap do |type|
+      assert_instance_of Types::Literal, type
+      assert_equal "Ωx", type.literal
+    end
+
+    # `end_pos` past the end of the buffer stays in bounds.
+    Parser.parse_type("Integer", byte_range: 0...9999).tap do |type|
+      assert_instance_of Types::ClassInstance, type
+    end
+  end
 end