mruby-regexp: fix MatchData#begin / #end for a group name and an out-of-range index - #7048

MatchData#begin and #end take their argument with mrb_get_args(mrb, "i", &idx),
so a group name is a TypeError before the method body runs, and an index that names
no group returns nil instead of raising.

md = /(?<_x>a)/.match("a")
md.begin(:_x)  # CRuby: 0,  mruby: TypeError (Symbol cannot be converted to Integer)
md.begin("_x") # CRuby: 0,  mruby: TypeError (String cannot be converted to Integer)
md.begin(:zz)  # CRuby: IndexError (undefined group name reference: zz)
               # mruby: TypeError (Symbol cannot be converted to Integer)

md = /(a)(b)/.match("ab")
md.begin(3)    # CRuby: IndexError (index 3 out of matches),  mruby: nil
md.begin(-1)   # CRuby: IndexError (index -1 out of matches), mruby: nil
md.end(-1)     # CRuby: IndexError (index -1 out of matches), mruby: nil

Both halves matter for the same reason: begin and end return an offset, and nil
is not one. Arithmetic on the result of a mistyped index fails somewhere else entirely,
while CRuby stops at the call.

What changes

matchdata_begin() and matchdata_end() take their argument as "o" and resolve it
before reading the capture:

• a String or Symbol resolves through the pattern's named-capture table, raising
  IndexError with undefined group name reference: NAME when it is not there
• an Integer outside 0...num_captures, negative included, raises IndexError with
  index N out of matches

This is deliberately stricter than MatchData#[], and CRuby is stricter here too:
[] returns nil for an index out of range because a group that did not participate
is also nil, whereas begin has no such value to return. []'s rules are untouched,
including the negative index it normalizes and the nil it returns out of range.

A group that exists but did not participate is still nil, which is the one result
that must not become a raise:

/(a)|(b)/.match("a").begin(2)   # both: nil

The name lookup was the loop matchdata_aref() already ran. It moves into a shared
matchdata_name_to_group() and gains begin and end as callers. The
RE_NAME_LEN_FITS() bound travels with it rather than staying behind: it is what keeps
the (uint32_t)name_len cast in the loop lossless, so begin and end get the
over-long name rejected for free. The IndexError for an unknown name moves with it as
well, since all three methods want the same message.

__byte_begin and __byte_end stay on "i" and keep returning nil. They are private,
are called only as md.__byte_begin(0) from String#gsub and #split in
mrblib/string_regexp.rb, and should not pay for the lookup on every iteration.

The bindings do not change: begin and end were already MRB_ARGS_REQ(1), which is
correct for an argument that is now an object rather than an integer.

Verification

Before:

$ ./build/host/bin/mruby -e 'p /(?<_x>a)/.match("a").begin(:_x)'
-e:1:in begin: Symbol cannot be converted to Integer (TypeError)
$ ./build/host/bin/mruby -e 'p /(a)(b)/.match("ab").begin(-1)'
nil

After, matching CRuby 4.0.6 on every line of the table above:

$ ./build/host/bin/mruby -e 'p /(?<_x>a)/.match("a").begin(:_x)'
0
$ ./build/host/bin/mruby -e 'p /(a)(b)/.match("ab").begin(-1)'
-e:1:in begin: index -1 out of matches (IndexError)

Tests

mrbgems/mruby-regexp/test/regexp.rb gains three blocks: the name cases beside the
existing MatchData#begin / #end assertion, the out-of-range cases including the
non-participating group that must stay nil, and the over-long name beside the
MatchData#[] regression test for the same bound, now that the lookup is shared.

rake test passes: 1970 assertions, 0 failures, no new compiler warnings.

Summary by CodeRabbit

• New Features

  • MatchData#begin and MatchData#end now support named capture groups using strings or symbols.
  • Named captures can be resolved consistently across match data access methods.

• Bug Fixes

  • Invalid capture names and indexes now raise IndexError.
  • Unmatched but valid capture groups continue to return nil.
  • Added support for correctly handling very long unknown capture names.