vm.c: answer str[i] = x from OP_SETIDX - #7215

OP_SETIDX implements []= in C for an Array and a Hash receiver and sends the operator for every other one, so a String store pays a method lookup and a call frame where the read side has answered str[i] from C since OP_GETIDX learned its String branch. This adds the write side, and then removes what would keep it switched off in a default build: mruby-regexp takes the []= name for a Regexp index, and a taken name disarms the slot the opcode compares against.

1. vm.c: answer str[i] = x from OP_SETIDX

A String branch mirroring the one in vm_op_getidx(): the same three index types (Integer, String and Range), the same test of the receiver's class against mrb->idx_class[], and the same arena save around a call that allocates where no cfunc epilogue will shrink the arena. mrb_str_aset() loses its static for it, as mrb_str_aref() did for the read side, and MRB_IDX_OP_STR_ASET joins the slots mrb_idx_op_update() rechecks.

A replacement that is not a String is a TypeError rather than a store, and is left to the send so that it is still raised with a String#[]= frame on the backtrace.

Nothing else changes hands: a subclass receiver, a singleton, a Float index and the three-argument form all reach the method exactly as before.

2. mruby-regexp: define the regexp-aware String#[]= in C

The override was def []=(*args) in mrblib. A Regexp was the first thing it ruled out, so every ordinary str[i] = x paid a Ruby frame and the two splat arrays a *args method builds to reach the mrb_str_aset() the core method reaches directly, and taking the name disarmed the branch added above.

str_aset() in src/regexp.c is the write side of the str_aref() that already lives there. It hands an Integer, String or Range index to the same mrb_str_aset() the opcode calls, which is the promise mrb_idx_op_rearm() asks for, so it re-arms MRB_IDX_OP_STR_ASET. A Regexp is none of the three: the opcode sends it, and it arrives at the search.

The arguments are read raw rather than with the core method's "oo|S!", because the regexp form has to search before it looks at the replacement: as in CRuby's rb_str_subpat_set(), a pattern that did not match raises IndexError whatever the replacement is, and leaves $~ describing the failure. The delegation repeats what "oo|S!" does, in its order, so every other form keeps the errors it raised, including str[1, 2, 3] = "X" being a TypeError for the third argument rather than an ArgumentError for the count.

slice! stays in mrblib and still reaches the core method under __aset, captured in C now, before the override takes the name.

Benchmark

# str[i] = x, 3M iterations
n = 3000000
s = "hello world"
i = 0
while i < n
  s[3] = "X"
  i += 1
end

# str[i, len] = repl, 3M iterations; str[re] = repl, 1M
s[1, 3] = "ell"
s[re] = "ll"     # re = /l+/

Wall clock is the best of 7 runs taken alternately from the two binaries (running one binary five times in a row and then the other reversed the result on this machine). Ir is Ir(2N) - Ir(N) per iteration under callgrind, which cancels startup.

Default gembox (byte indexed), gcc -g -O3:

The same gembox with mruby-regexp removed, which is what the first commit buys on its own, since there the core []= keeps the name and the slot stays armed:

Size

.text of libmruby.a, built in a clean directory per column.

Default gembox, byte indexed:

full-core gembox, MRB_UTF8_STRING:

gem_init.o shrinks because the mrblib []= and its irep are gone; its .data drops 224 bytes in both builds, which the totals above do not include.

Behaviour

A differential fuzz ran 4,967 []= calls on master and on this branch, each case tried both through the s[x] = repl syntax and through s.[]=(...), over empty, ASCII, multibyte and invalid-UTF-8 subjects, every index form (Integer, two Integers, Range, String, Regexp), every capture form (Integer, negative, out of range, Symbol, String, unknown name, nil, Float) and replacements including nil, a Symbol and an Integer. Each line records the receiver afterwards, the return value or the exception class and message, and $~. The output is identical in a byte build and in a MRB_UTF8_STRING build, and the same run is clean under ASan/UBSan and under MRB_GC_STRESS.

New tests: test/t/string.rb asks that a String#[]= redefined on String itself is reached (the Array and Hash equivalents are already there) and that the opcode and the method agree on every index form; mrbgems/mruby-regexp/test/string_index.rb asks the same both ways round for the re-armed opcode, which is what would catch str_aset() being widened to an argument type the opcode answers.

Tests

Both commits are green on their own: the first was run through ci/gcc-clang with the gem left as it is on master.

Environment

# build_config/default.rb (host)
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_COMPLEX -DMRB_USE_BIGINT -DMRB_USE_DEBUG_HOOK src/string.c

# ci/gcc-clang.rb (full-debug)
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -g3 -O0 -DMRB_GC_STRESS -DMRB_USE_DEBUG_HOOK -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 src/string.c

# ci/gcc-clang.rb (bintest)
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_GC_FIXED_ARENA -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 src/string.c

# ci/gcc-clang.rb (cxx_abi)
gcc -g -O3 -Wall -Wundef -Wwrite-strings -x c++ -std=gnu++03 -DMRB_GC_FIXED_ARENA -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 src/string.c

# ci/gcc-clang.rb (byte-string)
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c

# ci/gcc-clang.rb (ascii-case)
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CASE -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 src/string.c

# build_config/clang-asan.rb
clang -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -Wzero-length-array -fsanitize=address,undefined -g3 -O0 -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 src/string.c

# benchmark and size columns, default gembox (conf.gembox 'default')
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_COMPLEX -DMRB_USE_BIGINT -DMRB_USE_DEBUG_HOOK src/string.c

# size columns, full-core gembox (conf.gembox 'full-core')
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -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 src/string.c

# benchmark without mruby-regexp (conf.gembox 'default'; conf.gems.delete('mruby-regexp'))
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_SET -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_COMPLEX -DMRB_USE_BIGINT -DMRB_USE_DEBUG_HOOK src/string.c

Summary by CodeRabbit

• New Features

  • Expanded String#[]= support for integer, substring, range, regular expression, and capture-group assignments.
  • Added consistent assignment behavior for multibyte strings and replacement operations.

• Bug Fixes

  • Bracket assignment now honors method overrides and matches direct []= calls.
  • Improved validation and error handling for invalid indexes, replacements, captures, and frozen strings.
  • Added optimized handling for common string assignment operations.