mruby-regexp: apply /i to character classes - #7049

RE_FLAG_IGNORECASE is folded in only where compile_atom() emits a single
literal character. compile_charclass() never reads the flag, so every [...]
ignores /i.

/[abc]/i.match?("A")        # CRuby: true,  mruby: false
/[a-c]/i.match?("A")        # CRuby: true,  mruby: false
/[A-C]/i.match?("a")        # CRuby: true,  mruby: false
/[a-c]+/i.match?("AB")      # CRuby: true,  mruby: false

The inline and constructor forms of the flag reach the same code, so they fail
the same way.

/(?i)[a-c]/.match?("A")                              # CRuby: true, mruby: false
Regexp.new("[a-c]", Regexp::IGNORECASE).match?("A")  # CRuby: true, mruby: false

POSIX bracket classes are affected too, since they are merged into the same
bitmap.

/[[:lower:]]/i.match?("A")  # CRuby: true,  mruby: false
/[[:upper:]]/i.match?("a")  # CRuby: true,  mruby: false

A negated class is worse: it matches what it must reject, so a /i regexp
used for validation accepts input it should refuse. Nothing raises.

/[^a-c]/i.match?("A")       # CRuby: false, mruby: true

Fix

Fold the ASCII letters into the class bitmap at the end of
compile_charclass(), after the parse loop and before the class is committed
to an RE_CLASS or RE_NCLASS. That is the only point at which a [...] is
complete: the loop merges POSIX bracket bits, shorthands, ASCII ranges and
single literals into one bitmap, so a single pass there covers all four forms
and [[:lower:]] under /i picks up uppercase.

Negation is applied at match time against that same bitmap, so folding the
positive set fixes [^a-c] at the same time. class_add_shorthand() and
posix_class_bits() both run before the class is complete and would miss
plain literals and a-c ranges, so neither is the right place.

class_get_bit() is added alongside class_set_bit(). re_compile.c had no
bit-level reader for re_charclass::bitmap: first_set_walk() ORs whole
bytes, and the one bit test in the gem lives in class_match(), which is
static in another translation unit and takes a codepoint rather than a bit
index.

The fold has to happen at compile time rather than in the matcher for three
reasons. class_match() receives only a re_charclass and has no access to
any flags. pat->flags is the whole-pattern option set and so cannot see
inline (?i:...) scoping. And compute_first_set() derives pat->first_bytes
from the bitmap at compile time, which the matcher then uses to skip input; a
match time fold would leave that skip narrower than the class, and /[a-c]/i
would still fail on "A".

Reading c->flags is what makes the inline forms work: compile_atom()
already saves, replaces and restores it around (?i) and (?i:...), so the
class sees the scoped value with no further change.

The existing IGNORECASE blocks in compile_atom() are already correct for a
single literal and are left alone.

Scope

Non-ASCII case folding is not addressed. The codepoint range list and
cc->utf8_any are untouched, and class_add_range() and
class_add_codepoint() are unchanged.

Tests

mrbgems/mruby-regexp/test/regexp.rb:

• Regexp - case insensitive character class, a new block next to
  Regexp - case insensitive: the four positive forms, the
  Regexp::IGNORECASE constructor form, and both negated forms. It also
  guards the fold against widening the class past the ASCII letters, since
  [ and { are 32 apart but are not a case pair.
• Regexp - POSIX bracket classes: [[:upper:]] and [[:lower:]] under
  /i, next to the existing [[:upper:]] assertion.
• Regexp - inline options (?i) / (?i:...): (?i)[a-c], (?i:[a-c]), and
  that the option does not leak past the closing paren.

Verified on x86_64-linux:

• Every reproduction above now matches CRuby 4.0.6.
• rake test: 1968 total, 1950 OK, 0 KO, 0 crash, and bintest 105 OK.
• An MRB_INT32 build with clang and -Wall -Wextra: 1870 total, 1852 OK,
  0 KO, 0 crash, and no new warning from any mruby-regexp file.

Summary by CodeRabbit

• Bug Fixes

  • Improved case-insensitive regular expression matching for ASCII letters in character classes.
  • Added support for case-insensitive matching in ranges, shorthand classes, POSIX classes, and negated classes.
  • Ensured inline case-insensitive options remain limited to their intended scope.
  • Preserved existing behavior for non-ASCII character ranges.

• Tests

  • Added coverage for case-insensitive character classes, negation, POSIX classes, and ASCII boundary cases.