mruby-regexp: read \k<name> in a sub or gsub replacement - #7282

A replacement string reads \1 through \9 for a group the pattern numbered,
and \& for the whole match, but nothing read \k<name> for a group the
pattern named. The reference is copied out as the text it was spelled with, a
wrong answer that nothing reports:

"ab".sub(/(?<x>b)/, '\k<x>!')               # CRuby: "ab!",       mruby: "a\\k<x>!"
"abc".sub(/(?<x>b)(?<y>c)/, '\k<y>\k<x>')   # CRuby: "acb",       mruby: "a\\k<y>\\k<x>"
"abab".gsub(/(?<x>b)/, '<\k<x>>')           # CRuby: "a<b>a<b>",  mruby: "a<\\k<x>>a<\\k<x>>"
"ab".sub(/(?<x>b)/, '\k<y>')                # CRuby: IndexError,  mruby: "a\\k<y>"
"ab".sub(/(?<x>b)/, '\k<x')                 # CRuby: RuntimeError, mruby: "a\\k<x"

The pattern side reads the same spelling as a backreference, so a pattern can
name a group and refer to it within itself; the replacement is the one place
where the name says nothing.

The fix

apply_replacement() is handed the pattern the match was made with, and \k<
opens a reference to a group that pattern names:

• The name is the bytes up to the first >, with no escape among them, which
  is where CRuby ends it. Only this spelling opens a reference, so \k'name',
  which the pattern side does read as a backreference, stays the literal it was
  here as it does in CRuby, and so does a \k that no < follows.
• The group is asked of the pattern, not of the offsets the match left, so a
  name no group carries raises IndexError where a group of that name would
  only have stood for nothing. A pattern that names no group at all is asked
  the same question, and so is a literal String pattern, which has no group to
  name:

"ab".sub(/(?<x>c)?b/, '[\k<x>]')   # "a[]": the group took no part in the match
"ab".sub(/b/, '\k<y>')             # IndexError: undefined group name reference: y
"ab".sub("b", '\k<y>')             # IndexError: undefined group name reference: y

• An unclosed \k< is a mistake of a different kind and raises RuntimeError
  (invalid group name reference format), as CRuby has it.
• Nothing is asked of the pattern when nothing matched, a replacement being
  expanded once per match: "zz".sub(/(?<x>b)/, '\k<y>') answers "zz" on
  both sides.

The lookup itself is the one MatchData#[] makes for a String or Symbol name,
extracted so that both sides read a name the same way.

Two commits come before it. The capture buffer of __sub_str and __gsub_str
moves to the stack, where the block core beside them already keeps its own and
where __gsub_str's copy of the last match already stands, so that the raise
above leaves nothing behind; RE_MAX_CAPTURES bounds it at 256 bytes whatever
the pattern. Then the escapes that stand for a group (\0 to \9, \&, \+)
fold onto a single append, so that the new reference is one more way to say
which group is meant rather than a fourth copy of the copy-out.

Size

.text of bin/mruby, build_config/ci/gcc-clang.rb, each side from a clean
build directory at the same path. regexp.o is the only object that changes.

The two commits ahead of the reference are worth -80 to -384 of that on their
own: the fold is -48 in every build but full-debug, where it is -144, and the
buffer the rest. The reference costs +416 to +688 on top of them, and +560 to
+848 without the fold ahead of it, apply_replacement() being inlined into a
second, constant-propagated copy for the two literal cores, so that both copies
carry whatever the branch weighs.

Verification

The tests go in string_regexp.rb, beside the block for \&, \` and
\': what a name reaches, in sub, sub! and gsub, over two names, a
repeated name, a group that took no part in the match, and a multibyte name;
the four spellings that are not a reference; the names that reach no group,
through a named pattern, an unnamed one and a literal String pattern, with
group 0 and the empty name among them; and the unclosed \k<, including the
one at the very end of the replacement. Each case that raises has a companion
that matched nothing and so does not raise. 19 of the 26 assertions fail on
master.

Every case above was run against CRuby 4.0.6 first, and this branch answers all
26 as CRuby does.

rake test, build_config/ci/gcc-clang.rb, no compiler warning:

The default configuration: 2,157 total, 0 KO, 0 crash, plus its 112 bintests.

Environment

# ci/gcc-clang full-debug
gcc -MMD -c -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -g3 -O0 -DMRB_GC_STRESS -DMRB_USE_DEBUG_HOOK -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -I"include" -I"mrbgems/mruby-regexp/include" -I"build/full-debug/include" -o "build/full-debug/mrbgems/mruby-regexp/src/regexp.o" "mrbgems/mruby-regexp/src/regexp.c"

# ci/gcc-clang bintest
gcc -MMD -c -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_GC_FIXED_ARENA -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -DMRB_USE_DEBUG_HOOK -I"include" -I"mrbgems/mruby-regexp/include" -I"build/bintest/include" -o "build/bintest/mrbgems/mruby-regexp/src/regexp.o" "mrbgems/mruby-regexp/src/regexp.c"

# ci/gcc-clang cxx_abi
gcc -MMD -c -g -O3 -Wall -Wundef -Wwrite-strings -x c++ -std=gnu++03 -DMRB_GC_FIXED_ARENA -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_CXX_EXCEPTION -DMRB_USE_CXX_ABI -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -I"include" -I"mrbgems/mruby-regexp/include" -I"build/cxx_abi/include" -o "build/cxx_abi/mrbgems/mruby-regexp/src/regexp.o" "mrbgems/mruby-regexp/src/regexp.c"

# ci/gcc-clang byte-string
gcc -MMD -c -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -I"include" -I"mrbgems/mruby-regexp/include" -I"build/byte-string/include" -o "build/byte-string/mrbgems/mruby-regexp/src/regexp.o" "mrbgems/mruby-regexp/src/regexp.c"

# ci/gcc-clang ascii-ctype
gcc -MMD -c -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CTYPE -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -I"include" -I"mrbgems/mruby-regexp/include" -I"build/ascii-ctype/include" -o "build/ascii-ctype/mrbgems/mruby-regexp/src/regexp.o" "mrbgems/mruby-regexp/src/regexp.c"

Summary by CodeRabbit

• New Features

  • Replacement strings now support named capture references using \k<name> with String#sub, String#gsub, String#sub!, and String#gsub!.
  • Named references expand to the corresponding captured text, including multibyte names and repeated references.

• Bug Fixes

  • Invalid or undefined named references now produce clear errors.
  • Unmatched patterns leave replacement text unexpanded without raising errors.
  • Literal string substitutions correctly reject named capture references.