mruby-regexp: reject non-Regexp patterns in String#match and #match? - #6994

String#match and #match? converted a String argument to a Regexp
and handed self straight to anything else, so a pattern of the wrong
type reached a method call it does not respond to. The failure named the
argument as the receiver, which says nothing about the pattern being
wrong.

"abc".match(:b)   # CRuby: TypeError, mruby: NoMethodError for :b
"abc".match(nil)  # CRuby: TypeError, mruby: NoMethodError for nil

Resolve the pattern in one helper so both methods reject the same set,
and follow CRuby in naming nil, true and false by value and
everything else by class. The check runs before pos is inspected,
matching CRuby's order.

"abc".match(:b)       # TypeError: wrong argument type Symbol (expected Regexp)
"abc".match(nil, 99)  # TypeError on the pattern, not an error about pos

The helper is Regexp.__match_pattern, written in C, so nothing about the
check dispatches back to the argument. In Ruby it would, in two ways.
is_a? is a normal method call, so an argument that overrides it can pose
as a Regexp, reach .match(self, pos) and raise NoMethodError where
CRuby raises TypeError. Reading the type name from re.class likewise
lets the argument choose the name the message reports. The C helper reads
the kind and the class name off the object without dispatching.

class Liar
  def is_a?(klass) = true
end

class ClassLiar
  def class = Regexp
end

"abc".match(Liar.new)
# CRuby:  TypeError (wrong argument type Liar (expected Regexp))
# is_a?:  NoMethodError (undefined method 'match' for an instance of Liar)

"abc".match(ClassLiar.new)
# CRuby:     TypeError (wrong argument type ClassLiar (expected Regexp))
# re.class:  TypeError (wrong argument type Regexp (expected Regexp))

Putting it on Regexp rather than String also keeps it out of reach of
the receiver: String carries no helper for a subclass to redefine, and
String's public API does not grow a method only match and match?
call.

class Sub < String
  private def __match_pattern(re) = Regexp.new(re.to_s)
end

Sub.new("abc").match(:abc)
# on String:  a MatchData, the subclass widened what `match` accepts
# on Regexp:  TypeError (wrong argument type Symbol (expected Regexp))

The kind test accepts a subclass of the tested class, and that acceptance
is the part a future rewrite of the check could silently drop, so the
tests exercise a Regexp and a String subclass directly.

CRuby also accepts an object that defines to_str, converting it through
rb_check_string_type before the type check. mruby has no implicit
String conversion in core, so "a" + obj and "abc".index(obj)
already raise TypeError for such an object; honouring to_str in
match alone would make the gem more permissive than the core it sits
on. Rejecting to_str objects therefore stays an intentional
difference from CRuby.

String#=~ deliberately keeps its current behaviour. CRuby's
rb_str_match special-cases String only and dispatches everything else
as other =~ self.

"abc" =~ 1    # CRuby: NoMethodError, mruby: NoMethodError
"abc" =~ nil  # CRuby: nil,           mruby: NoMethodError

A blanket type check would turn both into TypeError, losing the case
mruby already matches and freezing the other in a state it can never grow
out of. Object#=~ was removed in Ruby 3.2, so nil is the only
receiver left to dispatch to, and the NoMethodError becomes CRuby's nil
the moment core gains NilClass#=~. That is a core fix rather than one
for this gem.

This becomes more urgent once Symbol#match exists (#6993).
Symbol#match and #match? delegate to to_s, so without the check the
receiver and the argument swap places and the call quietly succeeds.

"abc".match(:b)  # without the check: :b.to_s.match("abc") -> nil
                 # with the check:    TypeError

A Symbol receiver goes the same way, since Symbol#match delegates to
String#match and inherits whatever check it has.

:abc.match(:b)   # without the check: nil
                 # with the check:    TypeError
:abc.match?(:b)  # likewise false without the check
:abc.match(nil)  # NoMethodError without the check, TypeError with it

Both receivers are handled by the one helper this PR adds, so #6993 needs
no code of its own for them; only its tests for these rows have to wait
until the check exists.

#6993 touches none of the files this PR changes, so the two merge in either
order without a conflict. The order still matters for behaviour, though.
Merging #6993 first defines Symbol#match, which gives "abc".match(:b) a
receiver to dispatch to: it resolves to :b.to_s.match("abc") and quietly
returns nil where it used to raise NoMethodError. Merging this one first
closes that window, and #6993 needs no change either way.

rake test passes.

Summary by CodeRabbit

• Bug Fixes
  • Improved validation for String#match and String#match?.
  • String patterns continue to work, while unsupported pattern types now produce clear TypeError messages.
  • Pattern validation now occurs before position validation for more consistent behavior.
  • Fixed handling of values that incorrectly identify themselves as regular expressions.
  • Improved support for valid regular expression and string subclasses.