November 2023 - ruby-core - ml.ruby-lang.org

[ruby-core:115203] [Ruby master Bug#19981] bootstraptest/test_ractor.rb: Segmentation fault on arm32
by jaruga (Jun Aruga) 02 Jul '25

02 Jul '25

Issue #19981 has been reported by jaruga (Jun Aruga). ---------------------------------------- Bug #19981: bootstraptest/test_ractor.rb: Segmentation fault on arm32 https://bugs.ruby-lang.org/issues/19981 * Author: jaruga (Jun Aruga) * Status: Open * Priority: Normal * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- I faced the following segmentation fault on Ubuntu jammy arm32 (emulated environment by `SETARCH='setarch linux32 --verbose --32bit'`) in both Travis CI arm64 [log](https://app.travis-ci.com/github/ruby/ruby/jobs/612418476#L2422 ) and RubyCI arm64-neoverse server. I tested it on the latest ruby master branch `14fa5e39d72c84d3e12e10dc5d77a6e6200c10f5`. I was able to reproduce this issue on RubyCI arm64-neoverse server, and prepared the reproducing script. So, you can try to debug on the server. It seems that the `-O3` flag triggered the issue. Because I didn't see the issue when Travis CI setting `- optflags=-O1` in `.travis.yml` on the current master branch. https://github.com/junaruga/report-ruby-ractor-segmentation-fault ``` + arm-linux-gnueabihf-gcc --version arm-linux-gnueabihf-gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0 + setarch linux32 --verbose --32bit make -s test Switching on ADDR_LIMIT_32BIT. Execute command `make'. Fstderr output is not empty <internal:ractor>:760: [BUG] Segmentation fault at 0x0000000c ruby 3.3.0dev (2023-10-30T09:27:06Z master 14fa5e39d7) [armv8l-linux-eabihf] -- Control frame information ----------------------------------------------- c:0005 p:0003 s:0021 e:000020 METHOD <internal:ractor>:760 c:0004 p:0008 s:0014 e:000013 BLOCK bootstraptest.test_ractor.rb_541_1260.rb:4 c:0003 p:0018 s:0011 e:000010 METHOD <internal:kernel>:187 c:0002 p:0004 s:0006 e:000005 BLOCK bootstraptest.test_ractor.rb_541_1260.rb:3 [FINISH] c:0001 p:---- s:0003 e:000002 DUMMY [FINISH] -- Ruby level backtrace information ---------------------------------------- bootstraptest.test_ractor.rb_541_1260.rb:3:in `block in <main>' <internal:kernel>:187:in `loop' bootstraptest.test_ractor.rb_541_1260.rb:4:in `block (2 levels) in <main>' <internal:ractor>:760:in `yield' -- Threading information --------------------------------------------------- Total ractor count: 2 Ruby thread count for this ractor: 1 -- Machine register context ------------------------------------------------ r0: 0x00000000 r1: 0x00000001 r2: 0x00000007 r3: 0x00000000 r4: 0x00c935c8 r5: 0x00000002 r6: 0x00000002 r7: 0x00000000 r8: 0x00000004 r9: 0x00c646b0 r10: 0x00000002 sp: 0xd5d91c90 fau: 0x0000000c -- Other runtime information ----------------------------------------------- * Loaded script: bootstraptest.test_ractor.rb_541_1260.rb * Loaded features: 0 enumerator.so 1 thread.rb 2 fiber.so 3 rational.so 4 complex.so 5 ruby2_keywords.rb 6 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so 7 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so * Process memory map: 00640000-0093a000 r-xp 00000000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094a000-0094e000 r--p 002fa000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094e000-0094f000 rw-p 002fe000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094f000-00956000 rw-p 00000000 00:00 0 00bf3000-00cba000 rw-p 00000000 00:00 0 [heap] d5700000-d5721000 rw-p 00000000 00:00 0 d5721000-d5800000 ---p 00000000 00:00 0 d5900000-d5921000 rw-p 00000000 00:00 0 d5921000-d5a00000 ---p 00000000 00:00 0 d5a00000-d5a21000 rw-p 00000000 00:00 0 d5a21000-d5b00000 ---p 00000000 00:00 0 d5b00000-d5b21000 rw-p 00000000 00:00 0 d5b21000-d5c00000 ---p 00000000 00:00 0 d5c5f000-d5c60000 ---p 00000000 00:00 0 d5c60000-d5c90000 rw-p 00000000 00:00 0 d5c9f000-d5ca0000 ---p 00000000 00:00 0 d5ca0000-d5cd0000 rw-p 00000000 00:00 0 d5cde000-d5cdf000 ---p 00000000 00:00 0 d5cdf000-d5cef000 rw-p 00000000 00:00 0 d5cef000-d5cf0000 ---p 00000000 00:00 0 d5cf0000-d5d81000 rw-p 00000000 00:00 0 d5d81000-d5d82000 ---p 00000000 00:00 0 d5d82000-d5e12000 rw-p 00000000 00:00 0 d5e12000-d5e13000 ---p 00000000 00:00 0 d5e13000-d5ea3000 rw-p 00000000 00:00 0 d5ea3000-d5ea4000 ---p 00000000 00:00 0 d5ea4000-d5f34000 rw-p 00000000 00:00 0 d5f34000-d5f35000 ---p 00000000 00:00 0 d5f35000-d5fc5000 rw-p 00000000 00:00 0 d5fc5000-d5fc6000 ---p 00000000 00:00 0 d5fc6000-d6056000 rw-p 00000000 00:00 0 d6056000-d6057000 ---p 00000000 00:00 0 d6057000-d60e7000 rw-p 00000000 00:00 0 d60e7000-d60e8000 ---p 00000000 00:00 0 d60e8000-d6178000 rw-p 00000000 00:00 0 d6178000-d6179000 ---p 00000000 00:00 0 d6179000-d6209000 rw-p 00000000 00:00 0 d6209000-d620a000 ---p 00000000 00:00 0 d620a000-d629a000 rw-p 00000000 00:00 0 d629a000-d629b000 ---p 00000000 00:00 0 d629b000-d632b000 rw-p 00000000 00:00 0 d632b000-d632c000 ---p 00000000 00:00 0 d632c000-f5d10000 rw-p 00000000 00:00 0 f5d10000-f5d12000 r-xp 00000000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d12000-f5d21000 ---p 00002000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d21000-f5d22000 r--p 00001000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d22000-f5d23000 rw-p 00002000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d30000-f5d32000 r-xp 00000000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d32000-f5d41000 ---p 00002000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d41000-f5d42000 r--p 00001000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d42000-f5d43000 rw-p 00002000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d4f000-f5d50000 ---p 00000000 00:00 0 f5d50000-f5d71000 rw-p 00000000 00:00 0 f5d71000-f5d72000 ---p 00000000 00:00 0 f5d72000-f5d93000 rw-p 00000000 00:00 0 f5d93000-f5d94000 ---p 00000000 00:00 0 f5d94000-f5db5000 rw-p 00000000 00:00 0 f5db5000-f5db6000 ---p 00000000 00:00 0 f5db6000-f5dd7000 rw-p 00000000 00:00 0 f5dd7000-f5dd8000 ---p 00000000 00:00 0 f5dd8000-f5df9000 rw-p 00000000 00:00 0 f5df9000-f5dfa000 ---p 00000000 00:00 0 f5dfa000-f5e1b000 rw-p 00000000 00:00 0 f5e1b000-f5e1c000 ---p 00000000 00:00 0 f5e1c000-f5e3d000 rw-p 00000000 00:00 0 f5e3d000-f5e3e000 ---p 00000000 00:00 0 f5e3e000-f5e5f000 rw-p 00000000 00:00 0 f5e5f000-f5e60000 ---p 00000000 00:00 0 f5e60000-f66a0000 rw-p 00000000 00:00 0 f66af000-f73b0000 rw-p 00000000 00:00 0 f73b5000-f7436000 rw-p 00000000 00:00 0 f7436000-f76b0000 r--p 0006f000 103:03 11802136 /usr/lib/locale/locale-archive f76b0000-f78b0000 r--p 00000000 103:03 11802136 /usr/lib/locale/locale-archive f78b0000-f79bc000 r-xp 00000000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79bc000-f79cc000 ---p 0010c000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79cc000-f79ce000 r--p 0010c000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79ce000-f79cf000 rw-p 0010e000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79cf000-f79d9000 rw-p 00000000 00:00 0 f79e0000-f7a21000 r-xp 00000000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a21000-f7a30000 ---p 00041000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a30000-f7a31000 r--p 00040000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a31000-f7a32000 rw-p 00041000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a40000-f7a6b000 r-xp 00000000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a6b000-f7a7b000 ---p 0002b000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7b000-f7a7c000 r--p 0002b000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7c000-f7a7d000 rw-p 0002c000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7d000-f7a85000 rw-p 00000000 00:00 0 f7a88000-f7aa7000 r-xp 00000000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 f7aac000-f7ab3000 r--s 00000000 103:03 11670285 /usr/lib/arm-linux-gnueabihf/gconv/gconv-modules.cache f7ab3000-f7ab5000 rw-p 00000000 00:00 0 f7ab5000-f7ab6000 r-xp 00000000 00:00 0 [sigpage] f7ab6000-f7ab8000 r--p 0001e000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 f7ab8000-f7ab9000 rw-p 00020000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 ff7dd000-fffdc000 rw-p 00000000 00:00 0 [stack] ffff0000-ffff1000 r-xp 00000000 00:00 0 [vectors] ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111809] [Ruby master Bug#19338] Ruby hangs when defining new constant in ractor
by luke-gru (Luke Gruber) 13 May '25

13 May '25

Issue #19338 has been reported by luke-gru (Luke Gruber). ---------------------------------------- Bug #19338: Ruby hangs when defining new constant in ractor https://bugs.ruby-lang.org/issues/19338 * Author: luke-gru (Luke Gruber) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- This code causes Ruby to hang: ``` ruby rs = [] 2.times do rs << Ractor.new do MYCONSTANT = 2 end end rs.each(&:take) ``` There is a problem when the warning is being outputted with multiple ractors. A thread is calling RB_VM_LOCK() while holding the VM lock in ractor.c (ractor_check_blocking()) If the code is changed to RB_VM_LOCK_ENTER() and RB_VM_LOCK_LEAVE() then it fixes it, but I don't know if there's a better way. Thanks! -- https://bugs.ruby-lang.org/

3 3

[ruby-core:112207] [Ruby master Bug#19408] Object no longer frozen after moved from a ractor
by luke-gru (Luke Gruber) 08 May '25

08 May '25

Issue #19408 has been reported by luke-gru (Luke Gruber). ---------------------------------------- Bug #19408: Object no longer frozen after moved from a ractor https://bugs.ruby-lang.org/issues/19408 * Author: luke-gru (Luke Gruber) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- I think frozen objects should still be frozen after a move. ```ruby r = Ractor.new do obj = receive p obj.frozen? # should be true but is false p obj end obj = [Object.new].freeze r.send(obj, move: true) r.take ``` -- https://bugs.ruby-lang.org/

3 3

[ruby-core:114025] [Ruby master Feature#19744] Namespace on read
by tagomoris (Satoshi TAGOMORI) 06 May '25

06 May '25

Issue #19744 has been reported by tagomoris (Satoshi TAGOMORI). ---------------------------------------- Feature #19744: Namespace on read https://bugs.ruby-lang.org/issues/19744 * Author: tagomoris (Satoshi TAGOMORI) * Status: Open * Priority: Normal ---------------------------------------- # What is the "Namespace on read" This proposes a new feature to define virtual top-level namespaces in Ruby. Those namespaces can require/load libraries (either .rb or native extension) separately from the global namespace. Dependencies of required/loaded libraries are also required/loaded in the namespace. ### Motivation The "namespace on read" can solve the 2 problems below, and can make a path to solve another problem: The details of those motivations are described in the below section ("Motivation details"). #### Avoiding name conflicts between libraries Applications can require two different libraries safely which use the same module name. #### Avoiding unexpected globally shared modules/objects Applications can make an independent/unshared module instance. #### (In the future) Multiple versions of gems can be required Application developers will have fewer version conflicts between gem dependencies if rubygems/bundler will support the namespace on read. ### Example code with this feature ```ruby # your_module module YourModule end # my_module.rb require 'your_module' module MyModule end # example.rb namespace1 = NameSpace.new namespace1.require('my_module') #=> true namespace1::MyModule #=> #<Module:0x00000001027ea650>::MyModule (or #<NameSpace:0x00...>::MyModule ?) namespace1::YourModule # similar to the above MyModule # NameError YourModule # NameError namespace2 = NameSpace.new # Any number of namespaces can be defined namespace2.require('my_module') # Different library "instance" from namespace1 require 'my_module' # require in the global namespace MyModule.object_id != namespace1::MyModule.object_id #=> true namespace1::MyModule.object_id != namespace2::MyModule.object_id ``` The required/loaded libraries will define different "instances" of modules/classes in those namespaces (just like the "wrapper" 2nd argument of `Kernel.load`). This doesn't introduce compatibility problems if all libraries use relative name resolution (without forced top-level reference like `::Name`). # "On read": optional, user-driven feature "On read" is a key thing of this feature. That means: * No changes are required in existing/new libraries (except for limited cases, described below) * No changes are required in applications if it doesn't need namespaces * Users can enable/use namespaces just for limited code in the whole library/application Users can start using this feature step by step (if they want it) without any big jumps. ## Motivation details This feature can solve multiple problems I have in writing/executing Ruby code. Those are from the 3 problems I mentioned above: name conflicts, globally shared modules, and library version conflicts between dependencies. I'll describe 4 scenarios about those problems. ### Running multiple applications on a Ruby process Modern computers have many CPU cores and large memory spaces. We sometimes want to have many separate applications (either micro-service architecture or modular monolith). Currently, running those applications require different processes. It requires additional computation costs (especially in developing those applications). If we have isolated namespaces and can load applications in those namespaces, we'll be able to run apps on a process, with less overhead. (I want to run many AWS Lambda applications on a process in isolated namespaces.) ### Running tests in isolated namespaces Tests that require external libraries need many hacks to: * require a library multiple times * require many different 3rd party libraries into isolated spaces (those may conflict with each other) Software with plugin systems (for example, Fluentd) will get benefit from namespaces. In addition to it, application tests can avoid unexpected side effects if tests are executed in isolated namespaces. ### Safely isolated library instances Libraries may have globally shared states. For example, [Oj](https://github.com/ohler55/oj) has a global `Obj.default_options` object to change the library behavior. Those options may be changed by any dependency libraries or applications, and it changes the behavior of `Oj` globally, unexpectedly. For such libraries, we'll be able to instantiate a safe library instance in an isolated namespace. ### Avoiding dependency hells Modern applications use many libraries, and those libraries require much more dependencies. Those dependencies will cause version conflicts very often. In such cases, application developers should resolve those by updating each libraries, or should just wait for the new release of libraries to conflict those libraries. Sometimes, library maintainers don't release updated versions, and application developers can do nothing. If namespaces can require/load a library multiple times, it also enables to require/load different versions of a library in a process. It requires the support of rubygems, but namespaces should be a good fundamental of it. ## Expected problems ### Use of top-level references In my expectation, `::Name` should refer the top-level `Name` in the global namespace. I expect that `::ENV` should contain the environment variables. But it may cause compatibility problems if library code uses `::MyLibrary` to refer themselves in their deeply nested library code. ### Additional memory consumption An extension library (dynamically linked library) may be loaded multiple times (by `dlopen` for temporarily copied dll files) to load isolated library "instances" if different namespaces require the same extension library. That consumes additional memory. In my opinion, additional memory consumption is a minimum cost to realize loading extension libraries multiple times without compatibility issues. This occurs only when programmers use namespaces. And it's only about libraries that are used in 2 or more namespaces. ### The change of `dlopen` flag about extension libraries To load an extension library multiple times without conflicting symbols, all extensions should stop sharing symbols globally. Libraries referring symbols from other extension libraries will have to change code & dependencies. (About the things about extension libraries, [Naruse also wrote an entry](https://naruse.hateblo.jp/entry/2023/05/22/193411).) # Misc The proof-of-concept branch is here: https://github.com/tagomoris/ruby/pull/1 It's still work-in-progress branch, especially for extension libraries. -- https://bugs.ruby-lang.org/

17 70

[ruby-core:114410] [Ruby master Bug#19841] Marshal.dump stack overflow with recursive Time
by segiddins (Samuel Giddins) 29 Mar '25

29 Mar '25

Issue #19841 has been reported by segiddins (Samuel Giddins). ---------------------------------------- Bug #19841: Marshal.dump stack overflow with recursive Time https://bugs.ruby-lang.org/issues/19841 * Author: segiddins (Samuel Giddins) * Status: Open * Priority: Normal * ruby -v: 3.2.2 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- ``` ruby #!/usr/bin/env ruby puts RUBY_VERSION t = Time.at(0, 1, :nanosecond) t.instance_variable_set :@itself, t Marshal.dump(t) ``` Yields a stack overflow error from the `Marshal.dump` call, even though Marshal is explicitly able to handle cyclical references -- https://bugs.ruby-lang.org/

6 8

[ruby-core:114147] [Ruby master Bug#19765] Ractor.make_shareable ignores self of a proc created from a Method
by Ethan (Ethan -) 26 Mar '25

26 Mar '25

Issue #19765 has been reported by Ethan (Ethan -). ---------------------------------------- Bug #19765: Ractor.make_shareable ignores self of a proc created from a Method https://bugs.ruby-lang.org/issues/19765 * Author: Ethan (Ethan -) * Status: Open * Priority: Normal * ruby -v: ruby 3.3.0dev (2023-07-12T00:26:03Z master dfe782be17) [x86_64-darwin21] * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- An unshareable receiver of a Proc or a Method will cause make_shareable to error, but this does not happen with a proc from Method#to_proc: ```ruby str = "" a = str.instance_exec { proc { to_s } } Ractor.make_shareable a # => <internal:ractor>:820:in `make_shareable': Proc's self is not shareable: #<Proc:0x00000001064b62c8 (irb):1> (Ractor::IsolationError) b = str.instance_exec { method(:to_s) } Ractor.make_shareable b # => <internal:ractor>:820:in `make_shareable': can not make shareable object for #<Method: String#to_s()> (Ractor::Error) c = str.instance_exec { method(:to_s).to_proc } Ractor.make_shareable c c.call # => "" str[0] = "!" c.call # => "!" ``` Related, maybe: #19372 #19374 Tangential: why does Proc cause Ractor::IsolationError but Method causes Ractor::Error? -- https://bugs.ruby-lang.org/

3 2

[ruby-core:114936] [Ruby master Feature#19908] Update to Unicode 15.1
by nobu (Nobuyoshi Nakada) 17 Mar '25

17 Mar '25

Issue #19908 has been reported by nobu (Nobuyoshi Nakada). ---------------------------------------- Feature #19908: Update to Unicode 15.1 https://bugs.ruby-lang.org/issues/19908 * Author: nobu (Nobuyoshi Nakada) * Status: Assigned * Priority: Normal * Assignee: duerst (Martin Dürst) * Target version: 3.3 ---------------------------------------- The Unicode 15.1 is released. The current enc-unicode.rb seems to fail because of `Indic_Conjunct_break` properties with values. I'm not sure how these properties should be handled well. `/\p{InCB_Liner}/` or `/\p{InCB=Liner}/` as the comments in that file? https://github.com/nobu/ruby/tree/unicode-15.1 is the former. -- https://bugs.ruby-lang.org/

14 23

[ruby-core:113153] [Ruby master Bug#19584] Crash in rb_gc_register_address
by peterzhu2118 (Peter Zhu) 13 Mar '25

13 Mar '25

Issue #19584 has been reported by peterzhu2118 (Peter Zhu). ---------------------------------------- Bug #19584: Crash in rb_gc_register_address https://bugs.ruby-lang.org/issues/19584 * Author: peterzhu2118 (Peter Zhu) * Status: Open * Priority: Normal * Backport: 3.0: REQUIRED, 3.1: REQUIRED, 3.2: REQUIRED ---------------------------------------- GitHub PR: https://github.com/ruby/ruby/pull/7670 Some C extensions pass a pointer to a global variable to rb_gc_register_address. However, if a GC is triggered inside of rb_gc_register_address, then the object could get swept since it does not exist on the stack. -- https://bugs.ruby-lang.org/

4 6

[ruby-core:115512] [Ruby master Bug#20025] Parsing identifiers/constants is case-folding dependent
by kddnewton (Kevin Newton) 13 Mar '25

13 Mar '25

Issue #20025 has been reported by kddnewton (Kevin Newton). ---------------------------------------- Bug #20025: Parsing identifiers/constants is case-folding dependent https://bugs.ruby-lang.org/issues/20025 * Author: kddnewton (Kevin Newton) * Status: Open * Priority: Normal * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- When CRuby parses identifiers, it is encoding-dependent. Once the identifier is found, it determines if it starts with a uppercase or lowercase codepoint. This determines if the identifier is a constant or not. The function is charge of this is `rb_sym_constant_char_p`. For non-unicode encodings where the leading byte has the top-bit set, this relies on onigmo's `mbc_case_fold` to determine if it is a constant or not (as opposed to `is_code_ctype`). This works for almost every single codepoint in every encoding, but has one very weird edge case. In the Windows-1253 encoding for the 0xB5 byte, it's the micro sign. The micro sign, when case folded, becomes the uppercase mu character, and then the lowercase mu character, or 0xEC. This means that even though 0xB5 reports itself as being a lowercase codepoint, it gets parsed as a constant. This example might make this more clear: ``` ruby class Context < BasicObject def method_missing(name, *) = :identifier def self.const_missing(name) = :constant end encoding = Encoding::Windows_1253 character = 0xB5.chr(encoding) source = "# encoding: #{encoding.name}\n#{character}\n" result = Context.new.instance_eval(source) puts "#{encoding.name} encoding of 0x#{character.ord.to_s(16).upcase}" puts " [[:alpha:]] => #{character.match?(/[[:alpha:]]/)}" puts " [[:alnum:]] => #{character.match?(/[[:alnum:]]/)}" puts " [[:upper:]] => #{character.match?(/[[:upper:]]/)}" puts " [[:lower:]] => #{character.match?(/[[:lower:]]/)}" puts " parsed as #{result}" ``` this results in the output of: ``` Windows-1253 encoding of 0xB5 [[:alpha:]] => true [[:alnum:]] => true [[:upper:]] => false [[:lower:]] => true parsed as constant ``` To be clear, I don't think the case-folding is incorrect here (and @duerst confirms that it is correct). I believe instead that it is incorrect to use case-folding here to determine if a codepoint is uppercase or not. Note that this only impacts this one codepoint in this one encoding, so I don't believe this is actually a large-scale problem. But I found it surprising, and think we should change it. -- https://bugs.ruby-lang.org/

4 5

[ruby-core:112301] [Ruby master Bug#19426] Endless `Range#step` of object with `#succ` method does not work
by nobu (Nobuyoshi Nakada) 13 Mar '25

13 Mar '25

Issue #19426 has been reported by nobu (Nobuyoshi Nakada). ---------------------------------------- Bug #19426: Endless `Range#step` of object with `#succ` method does not work https://bugs.ruby-lang.org/issues/19426 * Author: nobu (Nobuyoshi Nakada) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- Consider this `c` object which hash `#succ` method. ```ruby c = Struct.new(:i) do def succ; self.class.new(i+1); end def <=>(other) i <=> other.i;end end.new(0) ``` This `Range#step` works. ```ruby (c..c.succ).step(1) do |d| p d.i # 0, 1 end ``` But it fails on an endless range. ```ruby (c..).step(1) do |d| p d.i break if d.i > 3 end ``` ``` -:3:in `<=>': undefined method `i' for nil:NilClass (NoMethodError) from -:10:in `step' from -:10:in `<main>' ``` -- https://bugs.ruby-lang.org/

3 4