Issue #20434 has been updated by Eregon (Benoit Daloze). This seems a good simplification to me, I think the semantics of these encoding modifiers are confusing to most Rubyists. I wouldn't be worried too much about length of the replacement, because `/.../s`/`/.../e` are likely very rare (using file encoding seems a good replacement for those). `/.../u` seems redundant with the default source encoding, so the `u` can likely just be removed in most cases. I'm not so sure `/.../n`, that may be more frequent. Methods to convert an existing Regexp from one encoding to another feel suboptiomal, because that will cause an extra Regexp instance and creating a Regexp is not cheap due to many checks, allocations, and even compilation (AFAIK eager in CRuby at least). So I think the existing `Regexp.new("a".dup.force_encoding(Encoding::WINDOWS_31J))` is good enough. And since this would address a deprecation, it seems very important that the code also works on older Ruby versions. (I'm all for `String#{encoded,with_encoding}` but it seems best to propose that as a separate ticket) I would be interested to have a good textual description in #20406 of how the encoding of a Regexp is computed currently, it seems quite complex, but having it in text would allow to reason more easily about it. Maybe we could simplify it while remaining compatible (i.e. the specific value of Regexp#encoding matters not so much, what matters is a Regexp can still be matched against Strings of various encoding like it could before). ---------------------------------------- Misc #20434: Deprecate encoding-related regular expression modifiers https://bugs.ruby-lang.org/issues/20434#change-108001 * Author: kddnewton (Kevin Newton) * Status: Open ---------------------------------------- This is a follow-up to @duerst's comment here: https://bugs.ruby-lang.org/issues/20406#note-6. As noted in the other issue, there are many encodings that factor in to how a regular expression operates. This includes: * The encoding of the file * The encoding of the string parts within the regular expression * The regular expression encoding modifiers * The encoding of the string being matched At the time the modifiers were introduced, I believe the modifiers may have been the only (??) encoding that factored in here. At this point, however, they can lead to quite a bit of confusion, as noted in the other ticket. I would like to propose to deprecate the regular expression encoding modifiers. Instead, we could suggest in a warning to instead create a regular expression with an encoded string. For example, when we find: ```ruby /\x81\x40/s ``` we would instead suggest: ```ruby ::Regexp.new(::String.new("\x81\x40", encoding: "Windows-31J")) ``` or equivalent. As a migration path, we could do the following: 1. Emit a warning to change to the suggested expression 2. Change the compiler to compile to the suggested expression when those flags are found 3. Remove support for the flags Step 2 may be unnecessary depending on how long of a timeline we would like to provide. To be clear, I'm not advocating for any particular timeline, and would be fine with this being multiple years/versions to give plenty of time for people to migrate. But I do think this would be a good change to eliminate confusion about the interaction between the four different encodings at play. -- https://bugs.ruby-lang.org/