- ruby-core - ml.ruby-lang.org

[ruby-core:122943] [Ruby Bug#21537] rb_ractor_sched_barrier_start() hangs on Windows
by rhenium (Kazuki Yamaguchi) 12 Aug '25

12 Aug '25

Issue #21537 has been reported by rhenium (Kazuki Yamaguchi). ---------------------------------------- Bug #21537: rb_ractor_sched_barrier_start() hangs on Windows https://bugs.ruby-lang.org/issues/21537 * Author: rhenium (Kazuki Yamaguchi) * Status: Open * ruby -v: ruby 3.5.0dev (2025-08-09T11:32:53Z master 2a6345e957) +PRISM [x64-mswin64_140] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- The following script hangs at `GC.start` indefinitely. Pressing Ctrl+C on the terminal interrupts the `sleep` and it appears to resume and prints "in_ractor". ```ruby Ractor.new { sleep 1 GC.start puts "in_ractor" } sleep ``` I also reproduced this with Ruby 3.0.7 from RubyInstaller2. Here is the stack trace with master: ``` 0:006> ~*k 0 Id: 1e88.36c4 Suspend: 1 Teb: 000000c6`92478000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`929fef18 00007ffa`9e4edf43 ntdll!NtWaitForMultipleObjects+0x14 01 000000c6`929fef20 00007ffa`9e4ede11 KERNELBASE!WaitForMultipleObjectsEx+0x123 02 000000c6`929ff210 00007ff6`756b8164 KERNELBASE!WaitForMultipleObjects+0x11 03 000000c6`929ff250 00007ff6`756b13af miniruby!w32_wait_events+0x108 [C:\w\ruby\thread_win32.c @ 239] 04 000000c6`929ff2d0 00007ff6`756b62a2 miniruby!native_sleep+0xc3 [C:\w\ruby\thread_win32.c @ 360] 05 000000c6`929ff310 00007ff6`75646353 miniruby!sleep_forever+0x82 [C:\w\ruby\thread.c @ 1374] 06 000000c6`929ff350 00007ff6`756e5f4b miniruby!rb_f_sleep+0x53 [C:\w\ruby\process.c @ 4975] 07 000000c6`929ff380 00007ff6`756e5df9 miniruby!vm_call_cfunc_with_frame_+0x14b [C:\w\ruby\vm_insnhelper.c @ 3850] 08 000000c6`929ff460 00007ff6`756e5dbb miniruby!vm_call_cfunc_with_frame+0x29 [C:\w\ruby\vm_insnhelper.c @ 3895] 09 000000c6`929ff4a0 00007ff6`756e5ab7 miniruby!vm_call_cfunc_other+0xc7 [C:\w\ruby\vm_insnhelper.c @ 3922] 0a 000000c6`929ff4e0 00007ff6`756e8363 miniruby!vm_call_cfunc+0x10b [C:\w\ruby\vm_insnhelper.c @ 4003] 0b 000000c6`929ff510 00007ff6`756e7cfe miniruby!vm_call_method_each_type+0x637 [C:\w\ruby\vm_insnhelper.c @ 4827] 0c 000000c6`929ff610 00007ff6`756f39b4 miniruby!vm_call_method+0x152 [C:\w\ruby\vm_insnhelper.c @ 4991] 0d 000000c6`929ff680 00007ff6`756ee003 miniruby!vm_sendish+0x1f4 [C:\w\ruby\vm_insnhelper.c @ 6065] 0e 000000c6`929ff700 00007ff6`756e0f27 miniruby!vm_exec_core+0x25cb [C:\w\ruby\insns.def @ 900] 0f (Inline Function) --------`-------- miniruby!vm_exec_loop+0x8 [C:\w\ruby\vm.c @ 2653] 10 000000c6`929ff860 00007ff6`755b896f miniruby!rb_vm_exec+0x10b [C:\w\ruby\vm.c @ 2624] 11 000000c6`929ff9d0 00007ff6`755baf47 miniruby!rb_ec_exec_node+0x10f [C:\w\ruby\eval.c @ 284] 12 000000c6`929ffb50 00007ff6`75531069 miniruby!ruby_run_node+0x43 [C:\w\ruby\eval.c @ 320] 13 (Inline Function) --------`-------- miniruby!rb_main+0x25 [C:\w\ruby\main.c @ 42] 14 (Inline Function) --------`-------- miniruby!w32_main+0x5f [C:\w\ruby\main.c @ 62] 15 000000c6`929ffb80 00007ff6`7575e3ec miniruby!wmain+0x69 [C:\w\ruby\main.c @ 48] 16 (Inline Function) --------`-------- miniruby!invoke_main+0x22 [D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 90] 17 000000c6`929ffbb0 00007ffa`a03de8d7 miniruby!__scrt_common_main_seh+0x10c [D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl @ 288] 18 000000c6`929ffbf0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 19 000000c6`929ffc20 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 1 Id: 1e88.1468 Suspend: 1 Teb: 000000c6`9247a000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`92dff618 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`92dff620 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`92dff980 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`92dff9b0 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 2 Id: 1e88.1058 Suspend: 1 Teb: 000000c6`9247c000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`931ff6a8 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`931ff6b0 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`931ffa10 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`931ffa40 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 3 Id: 1e88.158c Suspend: 1 Teb: 000000c6`9247e000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`935ff998 00007ffa`a103259e ntdll!NtWaitForWorkViaWorkerFactory+0x14 01 000000c6`935ff9a0 00007ffa`a03de8d7 ntdll!TppWorkerThread+0x37e 02 000000c6`935ffd00 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`935ffd30 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 4 Id: 1e88.3acc Suspend: 1 Teb: 000000c6`92480000 Unfrozen "ruby-timer-thread" # Child-SP RetAddr Call Site 00 000000c6`936ffbc8 00007ffa`9e4ecbbf ntdll!NtWaitForSingleObject+0x14 01 000000c6`936ffbd0 00007ff6`756b7e9d KERNELBASE!WaitForSingleObjectEx+0xaf 02 000000c6`936ffc70 00007ffa`9e0d37b0 miniruby!timer_thread_func+0x45 [C:\w\ruby\thread_win32.c @ 777] 03 000000c6`936ffca0 00007ffa`a03de8d7 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x30 04 000000c6`936ffcd0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 05 000000c6`936ffd00 00000000`00000000 ntdll!RtlUserThreadStart+0x2c 5 Id: 1e88.2934 Suspend: 1 Teb: 000000c6`92482000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`937ff4f8 00007ffa`9e4ecbbf ntdll!NtWaitForSingleObject+0x14 01 000000c6`937ff500 00007ff6`756b1276 KERNELBASE!WaitForSingleObjectEx+0xaf 02 000000c6`937ff5a0 00007ff6`756f7f47 miniruby!native_cond_timedwait_ms+0x62 [C:\w\ruby\thread_win32.c @ 483] 03 (Inline Function) --------`-------- miniruby!vm_cond_wait+0x28 [C:\w\ruby\vm_sync.c @ 211] 04 000000c6`937ff5f0 00007ff6`756b2c83 miniruby!rb_vm_cond_wait+0x37 [C:\w\ruby\vm_sync.c @ 220] 05 000000c6`937ff620 00007ff6`756f7f02 miniruby!rb_ractor_sched_barrier_start+0x67 [C:\w\ruby\thread_win32.c @ 956] 06 000000c6`937ff650 00007ff6`755c7a78 miniruby!rb_vm_barrier+0x1e [C:\w\ruby\vm_sync.c @ 265] 07 (Inline Function) --------`-------- miniruby!rb_gc_vm_barrier+0x5 [C:\w\ruby\gc.c @ 179] 08 (Inline Function) --------`-------- miniruby!gc_enter+0x25 [C:\w\ruby\gc\default\default.c @ 6609] 09 000000c6`937ff680 00007ff6`755c442e miniruby!gc_start+0xc0 [C:\w\ruby\gc\default\default.c @ 6334] 0a 000000c6`937ff6e0 00007ff6`755cdd0f miniruby!garbage_collect+0x42 [C:\w\ruby\gc\default\default.c @ 6316] 0b 000000c6`937ff710 00007ff6`755c2cc3 miniruby!rb_gc_impl_start+0x4b [C:\w\ruby\gc\default\default.c @ 6767] 0c 000000c6`937ff740 00007ff6`756d5c7b miniruby!gc_start_internal+0x4f [C:\w\ruby\gc.c @ 3447] 0d 000000c6`937ff780 00007ff6`756ee237 miniruby!builtin_invoker4+0x23 [C:\w\ruby\vm_insnhelper.c @ 7373] 0e (Inline Function) --------`-------- miniruby!invoke_bf+0x32 [C:\w\ruby\vm_insnhelper.c @ 7485] 0f (Inline Function) --------`-------- miniruby!vm_invoke_builtin+0x32 [C:\w\ruby\vm_insnhelper.c @ 7493] 10 000000c6`937ff7c0 00007ff6`756e0f27 miniruby!vm_exec_core+0x27ff [C:\w\ruby\build-debug\vm.inc @ 4621] 11 (Inline Function) --------`-------- miniruby!vm_exec_loop+0x8 [C:\w\ruby\vm.c @ 2653] 12 000000c6`937ff920 00007ff6`756f08b0 miniruby!rb_vm_exec+0x10b [C:\w\ruby\vm.c @ 2624] 13 (Inline Function) --------`-------- miniruby!invoke_iseq_block_from_c+0x1e3 [C:\w\ruby\vm.c @ 1651] 14 (Inline Function) --------`-------- miniruby!invoke_block_from_c_proc+0x2f2 [C:\w\ruby\vm.c @ 1745] 15 000000c6`937ffa90 00007ff6`756b6bf9 miniruby!vm_invoke_proc+0x324 [C:\w\ruby\vm.c @ 1775] 16 000000c6`937ffbd0 00007ff6`756b7987 miniruby!thread_do_start_proc+0x131 [C:\w\ruby\thread.c @ 584] 17 (Inline Function) --------`-------- miniruby!thread_do_start+0x37 [C:\w\ruby\thread.c @ 626] 18 000000c6`937ffc40 00007ff6`756b7720 miniruby!thread_start_func_2+0x243 [C:\w\ruby\thread.c @ 677] 19 000000c6`937ffe90 00007ffa`9e0d37b0 miniruby!thread_start_func_1+0x74 [C:\w\ruby\thread_win32.c @ 659] 1a 000000c6`937ffec0 00007ffa`a03de8d7 ucrtbase!thread_start<unsigned int (__cdecl*)(void *),1>+0x30 1b 000000c6`937ffef0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 1c 000000c6`937fff20 00000000`00000000 ntdll!RtlUserThreadStart+0x2c # 6 Id: 1e88.4f4 Suspend: 1 Teb: 000000c6`92486000 Unfrozen # Child-SP RetAddr Call Site 00 000000c6`93bff768 00007ffa`a10d793e ntdll!DbgBreakPoint 01 000000c6`93bff770 00007ffa`a03de8d7 ntdll!DbgUiRemoteBreakin+0x4e 02 000000c6`93bff7a0 00007ffa`a0fdc34c KERNEL32!BaseThreadInitThunk+0x17 03 000000c6`93bff7d0 00000000`00000000 ntdll!RtlUserThreadStart+0x2c ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:122951] [Ruby Feature#17316] On memoization
by Dan0042 (Daniel DeLorme) 11 Aug '25

11 Aug '25

Issue #17316 has been updated by Dan0042 (Daniel DeLorme). marksiemers (Mark Siemers) wrote in #note-12: > A big motivation for this comes from a recent change to rubocop-rails, which is now enforcing "Rails/FindByOrAssignmentMemoization" (see: https://rails.rubystyle.guide/\#find-by-memoization) > > A more rails-specific example below of this proposal: > ```ruby > # Previously allowed (though not performant in the case of nil returned by find_by) > def foo > @foo ||= Foo.find_by(id:) > end > > # The new rule enforces this syntax > def foo > if instance_variable_defined?(:@foo) > @foo > else > @foo = Foo.find_by(id:) > end > end > ``` This is appalling. If "best practices" are going to encourage this kind of un-ruby-ish horror, this memoization issue is more urgent to solve than I had expected. Personally I prefer a DSL like `memo def foo` but this `@||=` idea is pretty interesting in how it communicates this is a syntax that applies to instance variables. ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114255 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:121136] [Ruby master Bug#21151] IO and StringIO raise FrozenError even for read-only methods
by headius (Charles Nutter) 11 Aug '25

11 Aug '25

Issue #21151 has been reported by headius (Charles Nutter). ---------------------------------------- Bug #21151: IO and StringIO raise FrozenError even for read-only methods https://bugs.ruby-lang.org/issues/21151 * Author: headius (Charles Nutter) * Status: Open * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Problem -------- While fixing a small [regression](https://github.com/ruby/stringio/issues/119) from my recent StringIO [fixes](https://github.com/ruby/stringio/issues/116) I discovered that a large number of read-only methods will fail if the StringIO is frozen. A few examples: ``` $ ruby -rstringio -e 's = StringIO.new; p s.lineno; s.freeze; p s.lineno' 0 -e:1:in 'StringIO#lineno': can't modify frozen StringIO: #<StringIO:0x0000000103711ea8> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.closed?; s.freeze; p s.closed?' false -e:1:in 'StringIO#closed?': can't modify frozen StringIO: #<StringIO:0x00000001008c1e68> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.eof?; s.freeze; p s.eof?' true -e:1:in 'StringIO#eof?': can't modify frozen StringIO: #<StringIO:0x000000011c171e80> (FrozenError) from -e:1:in '<main>' $ ruby -rstringio -e 's = StringIO.new; p s.pos; s.freeze; p s.pos' 0 -e:1:in 'StringIO#pos': can't modify frozen StringIO: #<StringIO:0x0000000105551df0> (FrozenError) from -e:1:in '<main>' ``` @kou pointed out that IO also raises for at least `lineno` and suggested I re-open the issue here. I still believe these read-only operations should be allowed on frozen IO or StringIO. Cause in StringIO ----------------- This is because the `StringIO` macro calls `get_strio` which calls `rb_io_taint_check` which calls `rb_check_frozen`. The `StringIO` macro is used in almost every method to access the rb_stringio_t data structure. A list of methods I believe should be operable when the StringIO is frozen (in stringio.c definition order): * string (returns underlying String but does not mutate anything) * lineno * pos * closed?/closed_read?/closed_write? * eof/eof? * sync * pid (a dummy method but it writes nothing) * fileno (dummy) * pread (by definition does not modify state) * isatty/tty? * size/length * external_encoding * internal_encoding In addition, `initialize_copy` probably should not require the original StringIO to be writable: ``` $ ruby -rstringio -e 's = StringIO.new("foo"); s.freeze; p s.dup' -e:1:in 'StringIO#initialize_copy': can't modify frozen StringIO: #<StringIO:0x0000000102eb1df8> (FrozenError) from -e:1:in 'Kernel#initialize_dup' from -e:1:in 'Kernel#dup' from -e:1:in '<main>' ``` The data from the original StringIO is unmodified by `initialize_copy`, other than the reference-counting `ptr->count` (which should not be subject to frozen checks). Cause in IO ----------- The `GetOpenFile` macro calls `RB_IO_POINTER` macro which calls `rb_io_taint_check` which calls `rb_check_frozen`. Methods in IO that should work on a frozen IO include any of the above StringIO that currently raise. For example `lineno` uses `GetOpenFile`, but `fileno` does not and does not raise. There's clearly some inconsistency here we can clean up. Origin ------ I believe most of the StringIO cases are caused by this change from 2011 that added frozen checks to StringIO (the class and the macro): https://github.com/ruby/ruby/commit/d8d9bac5c8b071135e50ad3f21c8a9b6a9c06e54 In IO, this behavior dates way back to 2000 by @matz himself: https://github.com/ruby/ruby/commit/087c83d7ceed6893afff93066937fb570ae4a115 Notes ----- I have started to fix the StringIO cases for JRuby in https://github.com/ruby/stringio/pull/122. I could probably fix the C version of StringIO as well, but I'm a little more unsure about how to fix IO. -- https://bugs.ruby-lang.org/

3 4

[ruby-core:122948] [Ruby Feature#17316] On memoization
by marksiemers (Mark Siemers) 11 Aug '25

11 Aug '25

Issue #17316 has been updated by marksiemers (Mark Siemers). I agree with Sebastian that an operator is the best way to keep this code elegant. My proposal is to: **Introduce a new operator `@||` that does instance variable aware memoization succinctly** ```ruby # Allow this syntax def result @result @||= expensive_calculation end # As functionally equivalent to this def result if instance_variable_defined?(:@result) @result else @result = expensive_calculation end end ``` Reasons for this suggestion: 1. `@|` is already not valid syntax, so there should not be any issue with breaking legacy code 2. Use of the `@` symbol is a strong indicator that this impacts and is useful for instance variables 3. Keeping the `||` as part of the operator is familiar syntax for memoization 4. It is succinct, keeps things on one line, adds only one character, does not require blocks or method calls on separate lines (e.g. `memoize(:result)`) 5. If searching for memoization in the codebase - searching for `||=` will still work --- A big motivation for this comes from a recent change to rubocop-rails, which is now enforcing "Rails/FindByOrAssignmentMemoization" (see: https://rails.rubystyle.guide/\#find-by-memoization) A more rails-specific example below of this proposal: ```ruby # Previously allowed (though not performant in the case of nil returned by find_by def foo @foo ||= Foo.find_by(id:) end # The new rule enforces this syntax def foo if instance_variable_defined?(:@foo) @foo else @foo = Foo.find_by(id:) end end ``` Here's my main proposal with some reasons behind it: ```ruby def foo @foo @||= Foo.find_by(id:) end ``` --- Here are some other ideas, but I don't think any of them are as good as `@||`: ```ruby @result |||= expensive_calculation @result -||= expensive_calculation @result +||= expensive_calculation @result _||= expensive_calculation @result &||= expensive_calculation @result %||= expensive_calculation ``` ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114252 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122947] [Ruby Feature#21539] Facilitate walking native and interpreter (and jit?) stacks from outside of the ruby process
by dalehamel (Dale Hamel) 11 Aug '25

11 Aug '25

Issue #21539 has been reported by dalehamel (Dale Hamel). ---------------------------------------- Feature #21539: Facilitate walking native and interpreter (and jit?) stacks from outside of the ruby process https://bugs.ruby-lang.org/issues/21539 * Author: dalehamel (Dale Hamel) * Status: Open ---------------------------------------- While ruby does have a great API for getting stack traces within the ruby processes, as used by profilers like vernier and stackprof, there are some projects which aim to profile ruby from outside of the process. Some examples include: - rbspy (https://github.com/rbspy/rbspy/tree/main/ruby-structs/src) - rbperf (https://github.com/javierhonduco/rbperf) - open telemetry (https://github.com/open-telemetry/opentelemetry-ebpf-profiler/blob/main/sup…, https://github.com/open-telemetry/opentelemetry-ebpf-profiler/blob/main/int…) These first two take the approach of embedding the ruby headers within the profiler to be able to walk the stack. otel's bpf exporter was relying on access to symbols (https://github.com/open-telemetry/opentelemetry-ebpf-profiler/issues/202) which were removed some time ago https://github.com/ruby/ruby/pull/7459. As a result, it cannot profile newer rubies as it cannot unwind the stacks. All of these solutions kind of take the approach of trying to reverse engineer the ruby process and rely on somewhat hacky approaches that touch internal things that might frequently move around between ruby versions, and all feel a bit brittle. I think the root of this is that there is no public, stable api for this sort of external profiling. I'm not exactly sure what the solution should be, but it would be great for ruby to offer a recommended, supported, and stable way for external profilers (whether they are using perf api's or ptrace) to be able to: - Obtain the ruby native stack starting point, and walk it while being able to resolve the native symbols - Obtain a reference to the ruby execution context and walk the ruby interpreter stack - Have all of this work in a stable and reasonable way regardless of if / which ruby jit is enabled It would be awesome for some ruby maintainers / experts to weigh-in on what such an external API could look like. Perhaps a public header containing stable (or at least perhaps, versioned?) public symbols and perhaps structs as a starting point? This might necessitate that some fields be refactored out of existing structs, and could slow down work related to them (eg, members need to be added or removed). -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122945] [Ruby Bug#21538] initialize_dup not called when duping class/module
by chucke (Tiago Cardoso) 11 Aug '25

11 Aug '25

Issue #21538 has been reported by chucke (Tiago Cardoso). ---------------------------------------- Bug #21538: initialize_dup not called when duping class/module https://bugs.ruby-lang.org/issues/21538 * Author: chucke (Tiago Cardoso) * Status: Open * ruby -v: 3.4.5 * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Not sure whether this is expected behaviour or not, but just leaving it here to start the debate on whether callbacks like `initialize_dup` are supposed to be called when a module or class is duped (the same happens with `initialize_copy` and `initialize_clone` btw): class A def initialize_dup(_) puts "dup instance" super end def self.initialize_dup(_) puts "dup class" super end end A.new.dup #=> "dup instance" A.dup #=> nothing -- https://bugs.ruby-lang.org/

1 0

[ruby-core:116382] [Ruby master Feature#20205] Enable `frozen_string_literal` by default
by byroot (Jean Boussier) 10 Aug '25

10 Aug '25

Issue #20205 has been reported by byroot (Jean Boussier). ---------------------------------------- Feature #20205: Enable `frozen_string_literal` by default https://bugs.ruby-lang.org/issues/20205 * Author: byroot (Jean Boussier) * Status: Open * Priority: Normal ---------------------------------------- ### Context The `frozen_string_literal: true` pragma was introduced in Ruby 2.3, and as far as I'm aware the plan was initially to make it the default for Ruby 3.0, but this plan was abandoned because it would be too much of a breaking change without any real further notice. According to Matz, he still wishes to enable `frozen_string_literal` by default in the future, but a reasonable migration plan is required. The main issue is backward compatibility, flipping the switch immediately would break a lot of code, so there must be some deprecation period. The usual the path forward for this kind of change is to emit deprecation warnings one of multiple versions in advance. One example of that was the Ruby 2.7 keyword argument deprecation. It was quite verbose, and some users were initially annoyed, but I think the community pulled through it and I don't seem to hear much about it anymore. So for frozen string literals, the first step would be to start warning when a string that would be frozen in the future is mutated. ### Deprecation Warning Implementation I implemented a quick proof of concept with @etienne in https://github.com/Shopify/ruby/pull/549 In short: - Files with `# frozen_string_literal: true` or `# frozen_string_literal: false` don't change in behavior at all. - Files with no `# frozen_string_literal` comment are compiled to use `putchilledstring` opcode instead of regular `putstring`. - This opcode mark the string with a user flag, when these strings are mutated, a warning is issued. Currently the proof of concept issue the warning at the mutation location, which in some case can make locating where the string was allocated a bit hard. But it is possible to improve it so the message also include the location at which the literal string was allocated, and learning from the keyword argument warning experience, we can record which warnings were already issued to avoid spamming users with duplicated warnings. As currently implemented, there is almost no overhead. If we modify the implementation to record the literal location, we'd incur a small memory overhead for each literal string in a file without an explicit `frozen_string_literal` pragma. But I believe we could do it in a way that has no overhead if `Warning[:deprecated] = false`. ### Timeline The migration would happen in 3 steps, each step can potentially last multiple releases. e.g. `R0` could be `3.4`, `R1` be `3.7` and `R2` be `4.0`. I don't have a strong opinion on the pace. - Release `R0`: introduce the deprecation warning (only if deprecation warnings enabled). - Release `R1`: make the deprecation warning show up regardless of verbosity level. - Release `R2`: make string literals frozen by default. ### Impact Given that `rubocop` is quite popular in the community and it has enforced the usage of `# frozen_string_literal: true` for years now, I suspect a large part of the actively maintained codebases in the wild wouldn't see any warnings. And with recent versions of `minitest` enabling deprecation warnings by default (and [potentially RSpec too](https://github.com/rspec/rspec-core/issues/2867)) the few that didn't migrate will likely be made compatible quickly. The real problem of course are the less actively developed libraries and applications. For such cases, any codebase can remain compatible by setting `RUBYOPT="--disable=frozen_string_literal"`, and so even after `R2` release. The flag would never be removed any legacy codebase can continue upgrading Ruby without changing a single line of cod by just flipping this flag. ### Workflow for library maintainers As a library maintainer, fixing the deprecation warnings can be as simple as prepending `# frozen_string_literal: false` at the top of all their source files, and this will keep working forever. Alternatively they can of course make their code compatible with frozen string literals. Code that is frozen string literal compatible doesn't need to explicitly declare it. Only code that need it turned of need to do so. ### Workflow for application owners For application owners, the workflow is the same than for libraries. However if they depend on a gem that hasn't updated, or that they can't upgrade it, they can run their application with `RUBYOPT="--disable=frozen_string_literal"` and it will keep working forever. Any user running into an incompatibility issue can set `RUBYOPT="--disable=frozen_string_literal"` forever, even in `4.x`, the only thing changing is the default value. And any application for which all dependencies have been made fully frozen string literal compatible can set `RUBYOPT="--enable=frozen_string_literal"` and start immediately removing magic comment from their codebase. -- https://bugs.ruby-lang.org/

21 74

[ruby-core:122935] [Ruby Bug#21535] `NoMethodError` becomes `NameError`when using `...` delegation and method call indirection
by Earlopain (Earlopain _) 10 Aug '25

10 Aug '25

Issue #21535 has been reported by Earlopain (Earlopain _). ---------------------------------------- Bug #21535: `NoMethodError` becomes `NameError`when using `...` delegation and method call indirection https://bugs.ruby-lang.org/issues/21535 * Author: Earlopain (Earlopain _) * Status: Open * ruby -v: ruby 3.5.0dev (2025-08-08T02:57:23Z master 3ad26d0501) +PRISM [x86_64-linux] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Consider this code: ```rb class Test def foo(...) nil.foo(...) end def foo_indirect foo end end begin Test.new.foo rescue => e puts e.class end begin Test.new.foo_indirect rescue => e puts e.class end ``` ```sh $ ruby -v foo.rb ruby 3.3.6 (2024-11-05 revision 75015d4c1f) [x86_64-linux] NoMethodError NoMethodError $ ruby -v foo.rb ruby 3.5.0dev (2025-08-08T02:57:23Z master 3ad26d0501) +PRISM [x86_64-linux] NoMethodError NameError ``` On ruby 3.3 it used to always raise a `NoMethodError`. Starting with Ruby 3.4, it raises a `NoMethodError` when calling the method directly, and a `NameError` when the method is called indirectly via a different method. The context is the `delegate` method from rails (original issue https://github.com/rails/rails/issues/55463) which rescues the `NoMethodError` to raise a more specific error class. The problem is the `...` delegation. If the method accepts no arguments, `*, **`, or something else, it behaves as expected. -- https://bugs.ruby-lang.org/

2 2

[ruby-core:122939] [Ruby Bug#21536] ERROR: Error installing tk:
by sevkme (sevk kk) 09 Aug '25

09 Aug '25

Issue #21536 has been reported by sevkme (sevk kk). ---------------------------------------- Bug #21536: ERROR: Error installing tk: https://bugs.ruby-lang.org/issues/21536 * Author: sevkme (sevk kk) * Status: Open * ruby -v: ruby 3.4.4 (2025-05-14 revision a38531fd3f) +YJIT +PRISM [x86_64-linux] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ``` shell kkar4 :: ~ » pacman -Ss tcl | grep install extra/tcl 8.6.16-1 [installed] extra/tk 8.6.16-1 [installed] ``` ``` shell kkar4 :: ~ » CFLAGS="-Wold-style-definition" gem install tk Building native extensions. This could take a while... ERROR: Error installing tk: ERROR: Failed to build gem native extension. current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk /usr/bin/ruby extconf.rb check functions.checking for ruby_native_thread_p() in ruby.h... yes checking for rb_errinfo() in ruby.h... yes checking for rb_hash_lookup() in ruby.h... yes checking for rb_proc_new() in ruby.h... yes checking for rb_sourcefile() in ruby.h... yes checking for rb_thread_alive_p() in ruby.h... no checking for rb_thread_check_trap_pending() in ruby.h... yes checking for ruby_enc_find_basename() in ruby.h... yes check libraries.checking for t_open() in -lnsl... no checking for socket() in -lsocket... no checking for dlopen() in -ldl... yes checking for log() in -lm... yes Use ActiveTcl libraries (if available). Search tclConfig.sh and tkConfig.sh. Valid [tclConfig.sh, tkConfig.sh] are found in [["/usr/lib", "/usr/lib"], ["/usr/lib64", "/usr/lib64"]] Use [tclConfig.sh, tkConfig.sh] == ["/usr/lib/tclConfig.sh", "/usr/lib/tkConfig.sh"] Use X11 libraries (or use TK_XINCLUDES/TK_XLIBSW information on tkConfig.sh). checking for XOpenDisplay() in -lX11... yes creating Makefile Find Tcl/Tk libraries. Make tcltklib.so which is required by Ruby/Tk. current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk make DESTDIR\= sitearchdir\=./.gem.20250809-2512403-8d3buu sitelibdir\=./.gem.20250809-2512403-8d3buu clean current directory: /usr/lib/ruby/gems/3.4.0/gems/tk-0.5.1/ext/tk make DESTDIR\= sitearchdir\=./.gem.20250809-2512403-8d3buu sitelibdir\=./.gem.20250809-2512403-8d3buu compiling stubs.c stubs.c: In function '_nativethread_consistency_check': stubs.c:42:1: warning: old-style function definition [-Wold-style-definition] 42 | _nativethread_consistency_check(ip) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ compiling tcltklib.c tcltklib.c: In function 'get_ip': tcltklib.c:784:1: warning: old-style function definition [-Wold-style-definition] 784 | get_ip(self) | ^~~~~~ tcltklib.c: In function 'deleted_ip': tcltklib.c:802:1: warning: old-style function definition [-Wold-style-definition] 802 | deleted_ip(ptr) | ^~~~~~~~~~ tcltklib.c: In function 'rbtk_preserve_ip': tcltklib.c:818:1: warning: old-style function definition [-Wold-style-definition] 818 | rbtk_preserve_ip(ptr) | ^~~~~~~~~~~~~~~~ tcltklib.c: In function 'rbtk_release_ip': tcltklib.c:832:1: warning: old-style function definition [-Wold-style-definition] 832 | rbtk_release_ip(ptr) | ^~~~~~~~~~~~~~~ tcltklib.c: In function 'tcltkip_init_tk': tcltklib.c:1327:1: warning: old-style function definition [-Wold-style-definition] 1327 | tcltkip_init_tk(interp) | ^~~~~~~~~~~~~~~ tcltklib.c: In function 'pending_exception_check1': tcltklib.c:1435:1: warning: old-style function definition [-Wold-style-definition] 1435 | pending_exception_check1(thr_crit_bup, ptr) | ^~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'call_original_exit': tcltklib.c:1480:1: warning: old-style function definition [-Wold-style-definition] 1480 | call_original_exit(ptr, state) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function '_timer_for_tcl': tcltklib.c:1631:1: warning: old-style function definition [-Wold-style-definition] 1631 | _timer_for_tcl(clientData) | ^~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_window_mode': tcltklib.c:1682:1: warning: old-style function definition [-Wold-style-definition] 1682 | set_eventloop_window_mode(self, mode) | ^~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_window_mode': tcltklib.c:1697:1: warning: old-style function definition [-Wold-style-definition] 1697 | get_eventloop_window_mode(self) | ^~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_tick': tcltklib.c:1708:1: warning: old-style function definition [-Wold-style-definition] 1708 | set_eventloop_tick(self, tick) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_tick': tcltklib.c:1742:1: warning: old-style function definition [-Wold-style-definition] 1742 | get_eventloop_tick(self) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_eventloop_tick': tcltklib.c:1749:1: warning: old-style function definition [-Wold-style-definition] 1749 | ip_set_eventloop_tick(self, tick) | ^~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_eventloop_tick': tcltklib.c:1768:1: warning: old-style function definition [-Wold-style-definition] 1768 | ip_get_eventloop_tick(self) | ^~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_no_event_wait': tcltklib.c:1775:1: warning: old-style function definition [-Wold-style-definition] 1775 | set_no_event_wait(self, wait) | ^~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_no_event_wait': tcltklib.c:1793:1: warning: old-style function definition [-Wold-style-definition] 1793 | get_no_event_wait(self) | ^~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_no_event_wait': tcltklib.c:1800:1: warning: old-style function definition [-Wold-style-definition] 1800 | ip_set_no_event_wait(self, wait) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_no_event_wait': tcltklib.c:1819:1: warning: old-style function definition [-Wold-style-definition] 1819 | ip_get_no_event_wait(self) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_eventloop_weight': tcltklib.c:1826:1: warning: old-style function definition [-Wold-style-definition] 1826 | set_eventloop_weight(self, loop_max, no_event) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'get_eventloop_weight': tcltklib.c:1846:1: warning: old-style function definition [-Wold-style-definition] 1846 | get_eventloop_weight(self) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_set_eventloop_weight': tcltklib.c:1853:1: warning: old-style function definition [-Wold-style-definition] 1853 | ip_set_eventloop_weight(self, loop_max, no_event) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_get_eventloop_weight': tcltklib.c:1873:1: warning: old-style function definition [-Wold-style-definition] 1873 | ip_get_eventloop_weight(self) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'set_max_block_time': tcltklib.c:1880:1: warning: old-style function definition [-Wold-style-definition] 1880 | set_max_block_time(self, time) | ^~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_thread_p': tcltklib.c:1913:1: warning: old-style function definition [-Wold-style-definition] 1913 | lib_evloop_thread_p(self) | ^~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_abort_on_exc': tcltklib.c:1926:1: warning: old-style function definition [-Wold-style-definition] 1926 | lib_evloop_abort_on_exc(self) | ^~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_evloop_abort_on_exc': tcltklib.c:1939:1: warning: old-style function definition [-Wold-style-definition] 1939 | ip_evloop_abort_on_exc(self) | ^~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_evloop_abort_on_exc_set': tcltklib.c:1946:1: warning: old-style function definition [-Wold-style-definition] 1946 | lib_evloop_abort_on_exc_set(self, val) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'ip_evloop_abort_on_exc_set': tcltklib.c:1960:1: warning: old-style function definition [-Wold-style-definition] 1960 | ip_evloop_abort_on_exc_set(self, val) | ^~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_num_of_mainwindows_core': tcltklib.c:1979:1: warning: old-style function definition [-Wold-style-definition] 1979 | lib_num_of_mainwindows_core(self, argc, argv) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_num_of_mainwindows': tcltklib.c:1992:1: warning: old-style function definition [-Wold-style-definition] 1992 | lib_num_of_mainwindows(self) | ^~~~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'call_DoOneEvent': tcltklib.c:2045:21: error: passing argument 1 of 'tk_funcall' from incompatible pointer type [-Wincompatible-pointer-types] 2045 | return tk_funcall(call_DoOneEvent_core, 0, (VALUE*)NULL, flag_val); | ^~~~~~~~~~~~~~~~~~~~ | | | VALUE (*)(VALUE) {aka long unsigned int (*)(long unsigned int)} In file included from /usr/include/ruby-3.4.0/ruby/defines.h:77, from /usr/include/ruby-3.4.0/ruby/ruby.h:25, from /usr/include/ruby-3.4.0/ruby.h:38, from tcltklib.c:10: tcltklib.c:258:28: note: expected 'VALUE (*)(void)' {aka 'long unsigned int (*)(void)'} but argument is of type 'VALUE (*)(VALUE)' {aka 'long unsigned int (*)(long unsigned int)'} 258 | static VALUE tk_funcall _((VALUE(), int, VALUE*, VALUE)); | ^~~~~~~ /usr/include/ruby-3.4.0/ruby/backward/2/stdarg.h:33:18: note: in definition of macro '_' 33 | # define _(args) args | ^~~~ tcltklib.c:2021:1: note: 'call_DoOneEvent_core' declared here 2021 | call_DoOneEvent_core(VALUE flag_val) | ^~~~~~~~~~~~~~~~~~~~ tcltklib.c: In function 'lib_eventloop_core': tcltklib.c:2197:1: warning: old-style function definition [-Wold-style-definition] 2197 | lib_eventloop_core(check_root, update_flag, check_var, interp) | ^~~~~~~~~~~~~~~~~~ ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:122915] [Ruby Bug#21531] /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env
by yahonda (Yasuo Honda) 07 Aug '25

07 Aug '25

Issue #21531 has been reported by yahonda (Yasuo Honda). ---------------------------------------- Bug #21531: /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env https://bugs.ruby-lang.org/issues/21531 * Author: yahonda (Yasuo Honda) * Status: Open * ruby -v: 3.5.0p-1 (2025-08-02 revision fca2e6f8f53920170654e696c2585fcd3f4ebe11) [x86_64-linux] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Rails CI is consistently throwing assertion failures, but I can't replicate this behavior locally yet. https://buildkite.com/rails/rails-nightly/builds/2619#0198676f-b98c-4c4e-a6… ``` /usr/local/bin/ruby -w -I"lib:test" /usr/local/lib/ruby/gems/3.5.0+2/gems/rake-13.3.0/lib/rake/rake_test_loader.rb "test/activejob/destroy_association_async_job_test.rb" "test/activejob/destroy_association_async_test.rb" "test/activejob/job_checkpoints_test.rb" "test/activejob/job_runtime_test.rb" --profile /usr/local/lib/ruby/gems/3.5.0+2/gems/i18n-1.14.7/lib/i18n/exceptions.rb:3: warning: CGI library is removed from Ruby 3.5. Please use cgi/escape instead for CGI.escape and CGI.unescape features. If you need to use the full features of CGI library, Please install cgi gem. /usr/src/ruby/vm_insnhelper.c:131: Assertion Failed: callable_method_entry_p:IMEMO_TYPE_P((VALUE)cme, imemo_ment): imemo_type:env ruby 3.5.0dev (2025-08-01T16:00:05Z master fca2e6f8f5) +PRISM [x86_64-linux] ``` ### Environment - Using rubylang/ruby:master-debug Docker image provided via https://hub.docker.com/r/rubylang/ruby/ - Last successful build with Ruby 3.5.0p-1 (2025-08-01 revision b3598cf2a355497693bb66097edc156af3152e9b) [x86_64-linux] https://buildkite.com/rails/rails-nightly/builds/2614#01986249-5d8f-4315-ba… - I suspect this problem was introduced by one of the commits in this range: https://github.com/ruby/ruby/compare/b3598cf2a355497693bb66097edc156af3152e… -- https://bugs.ruby-lang.org/

2 1