From 3c16d93cd3a7c4d1362e07070c9ed9826a7272a8 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 23:12:02 +0900
Subject: [PATCH 001/242] Constify encoding type in universal parser

Fixed warning about discarding modifiers.

```
../src/ruby_parser.c:677:48: warning: passing 'rb_encoding *' (aka 'const struct OnigEncodingTypeST *') to parameter of type 'void *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers]
  677 |     ast = rb_parser_compile(p, gets, ptr, len, enc, input, line);
      |                                                ^~~
../src/internal/parse.h:58:128: note: passing argument to parameter 'fname_enc' here
   58 | rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, const char *fname_ptr, long fname_len, rb_encoding *fname_enc, rb_parser_input_data input, int line);
      |                                                                                                                                ^
```
---
 internal/parse.h   |  2 +-
 ruby_parser.c      | 98 +++++++++++++++++++++++-----------------------
 rubyparser.h       |  2 +-
 universal_parser.c |  2 +-
 4 files changed, 53 insertions(+), 51 deletions(-)

diff --git a/internal/parse.h b/internal/parse.h
index a7e8e08912315f..5f52e8a8e3aacf 100644
--- a/internal/parse.h
+++ b/internal/parse.h
@@ -13,7 +13,7 @@
 #include "internal/static_assert.h"
 
 #ifdef UNIVERSAL_PARSER
-#define rb_encoding void
+#define rb_encoding const void
 #endif
 
 struct rb_iseq_struct;          /* in vm_core.h */
diff --git a/ruby_parser.c b/ruby_parser.c
index f9d4e6d59ce0ac..1dcdfd8e79ecd8 100644
--- a/ruby_parser.c
+++ b/ruby_parser.c
@@ -32,6 +32,8 @@
 #include "vm_core.h"
 #include "symbol.h"
 
+#define parser_encoding const void
+
 static int
 is_ascii_string2(VALUE str)
 {
@@ -41,9 +43,9 @@ is_ascii_string2(VALUE str)
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
 static VALUE
 syntax_error_append(VALUE exc, VALUE file, int line, int column,
-                       void *enc, const char *fmt, va_list args)
+                    parser_encoding *enc, const char *fmt, va_list args)
 {
-    return rb_syntax_error_append(exc, file, line, column, (rb_encoding *)enc, fmt, args);
+    return rb_syntax_error_append(exc, file, line, column, enc, fmt, args);
 }
 
 static int
@@ -59,9 +61,9 @@ dvar_defined(ID id, const void *p)
 }
 
 static int
-is_usascii_enc(void *enc)
+is_usascii_enc(parser_encoding *enc)
 {
-    return rb_is_usascii_enc((rb_encoding *)enc);
+    return rb_is_usascii_enc(enc);
 }
 
 static int
@@ -83,21 +85,21 @@ is_notop_id2(ID id)
 }
 
 static VALUE
-enc_str_new(const char *ptr, long len, void *enc)
+enc_str_new(const char *ptr, long len, parser_encoding *enc)
 {
-    return rb_enc_str_new(ptr, len, (rb_encoding *)enc);
+    return rb_enc_str_new(ptr, len, enc);
 }
 
 static int
-enc_isalnum(OnigCodePoint c, void *enc)
+enc_isalnum(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isalnum(c, (rb_encoding *)enc);
+    return rb_enc_isalnum(c, enc);
 }
 
 static int
-enc_precise_mbclen(const char *p, const char *e, void *enc)
+enc_precise_mbclen(const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_precise_mbclen(p, e, (rb_encoding *)enc);
+    return rb_enc_precise_mbclen(p, e, enc);
 }
 
 static int
@@ -113,93 +115,93 @@ mbclen_charfound_len(int len)
 }
 
 static const char *
-enc_name(void *enc)
+enc_name(parser_encoding *enc)
 {
-    return rb_enc_name((rb_encoding *)enc);
+    return rb_enc_name(enc);
 }
 
 static char *
-enc_prev_char(const char *s, const char *p, const char *e, void *enc)
+enc_prev_char(const char *s, const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_prev_char(s, p, e, (rb_encoding *)enc);
+    return rb_enc_prev_char(s, p, e, enc);
 }
 
-static void *
+static parser_encoding *
 enc_get(VALUE obj)
 {
-    return (void *)rb_enc_get(obj);
+    return rb_enc_get(obj);
 }
 
 static int
-enc_asciicompat(void *enc)
+enc_asciicompat(parser_encoding *enc)
 {
-    return rb_enc_asciicompat((rb_encoding *)enc);
+    return rb_enc_asciicompat(enc);
 }
 
-static void *
+static parser_encoding *
 utf8_encoding(void)
 {
-    return (void *)rb_utf8_encoding();
+    return rb_utf8_encoding();
 }
 
 static VALUE
-enc_associate(VALUE obj, void *enc)
+enc_associate(VALUE obj, parser_encoding *enc)
 {
-    return rb_enc_associate(obj, (rb_encoding *)enc);
+    return rb_enc_associate(obj, enc);
 }
 
-static void *
+static parser_encoding *
 ascii8bit_encoding(void)
 {
-    return (void *)rb_ascii8bit_encoding();
+    return rb_ascii8bit_encoding();
 }
 
 static int
-enc_codelen(int c, void *enc)
+enc_codelen(int c, parser_encoding *enc)
 {
-    return rb_enc_codelen(c, (rb_encoding *)enc);
+    return rb_enc_codelen(c, enc);
 }
 
 static int
-enc_mbcput(unsigned int c, void *buf, void *enc)
+enc_mbcput(unsigned int c, void *buf, parser_encoding *enc)
 {
-    return rb_enc_mbcput(c, buf, (rb_encoding *)enc);
+    return rb_enc_mbcput(c, buf, enc);
 }
 
 static int
-enc_mbclen(const char *p, const char *e, void *enc)
+enc_mbclen(const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_mbclen(p, e, (rb_encoding *)enc);
+    return rb_enc_mbclen(p, e, enc);
 }
 
-static void *
+static parser_encoding *
 enc_from_index(int idx)
 {
-    return (void *)rb_enc_from_index(idx);
+    return rb_enc_from_index(idx);
 }
 
 static int
-enc_isspace(OnigCodePoint c, void *enc)
+enc_isspace(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isspace(c, (rb_encoding *)enc);
+    return rb_enc_isspace(c, enc);
 }
 
 static ID
-intern3(const char *name, long len, void *enc)
+intern3(const char *name, long len, parser_encoding *enc)
 {
-    return rb_intern3(name, len, (rb_encoding *)enc);
+    return rb_intern3(name, len, enc);
 }
 
-static void *
+static parser_encoding *
 usascii_encoding(void)
 {
-    return (void *)rb_usascii_encoding();
+    return rb_usascii_encoding();
 }
 
 static int
-enc_symname_type(const char *name, long len, void *enc, unsigned int allowed_attrset)
+enc_symname_type(const char *name, long len, parser_encoding *enc, unsigned int allowed_attrset)
 {
-    return rb_enc_symname_type(name, len, (rb_encoding *)enc, allowed_attrset);
+    return rb_enc_symname_type(name, len, enc, allowed_attrset);
 }
 
 typedef struct {
@@ -220,7 +222,7 @@ reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
     long len = name_end - name;
     const char *s = (const char *)name;
 
-    return rb_reg_named_capture_assign_iter_impl(p, s, len, (void *)enc, &arg->succ_block, loc);
+    return rb_reg_named_capture_assign_iter_impl(p, s, len, enc, &arg->succ_block, loc);
 }
 
 static NODE *
@@ -305,25 +307,25 @@ static_id2sym(ID id)
 }
 
 static long
-str_coderange_scan_restartable(const char *s, const char *e, void *enc, int *cr)
+str_coderange_scan_restartable(const char *s, const char *e, parser_encoding *enc, int *cr)
 {
-    return rb_str_coderange_scan_restartable(s, e, (rb_encoding *)enc, cr);
+    return rb_str_coderange_scan_restartable(s, e, enc, cr);
 }
 
 static int
-enc_mbminlen(void *enc)
+enc_mbminlen(parser_encoding *enc)
 {
-    return rb_enc_mbminlen((rb_encoding *)enc);
+    return rb_enc_mbminlen(enc);
 }
 
 static bool
-enc_isascii(OnigCodePoint c, void *enc)
+enc_isascii(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isascii(c, (rb_encoding *)enc);
+    return rb_enc_isascii(c, enc);
 }
 
 static OnigCodePoint
-enc_mbc_to_codepoint(const char *p, const char *e, void *enc)
+enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
 {
     const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
     const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
diff --git a/rubyparser.h b/rubyparser.h
index cb90b847b66769..fc8be9633aa2ae 100644
--- a/rubyparser.h
+++ b/rubyparser.h
@@ -9,7 +9,7 @@
 
 #ifdef UNIVERSAL_PARSER
 
-#define rb_encoding void
+#define rb_encoding const void
 #define OnigCodePoint unsigned int
 #include "parser_st.h"
 #ifndef RUBY_RUBY_H
diff --git a/universal_parser.c b/universal_parser.c
index 05445587ba0bc9..c5e557ca30370a 100644
--- a/universal_parser.c
+++ b/universal_parser.c
@@ -59,7 +59,7 @@
 #undef st_lookup
 #define st_lookup rb_parser_st_lookup
 
-#define rb_encoding void
+#define rb_encoding const void
 
 #undef xmalloc
 #define xmalloc p->config->malloc

From e9262983430e7a758a4151e39151062ac00d67bf Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Fri, 10 May 2024 16:11:51 +0200
Subject: [PATCH 002/242] [rubygems/rubygems] Require things right before
 they're needed

https://github.com/rubygems/rubygems/commit/07022e3f2f
---
 lib/bundler/rubygems_ext.rb | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/lib/bundler/rubygems_ext.rb b/lib/bundler/rubygems_ext.rb
index a7539f4adb7d46..0cd94d60ce6e9c 100644
--- a/lib/bundler/rubygems_ext.rb
+++ b/lib/bundler/rubygems_ext.rb
@@ -4,8 +4,6 @@
 
 require "rubygems" unless defined?(Gem)
 
-require "rubygems/specification"
-
 # We can't let `Gem::Source` be autoloaded in the `Gem::Specification#source`
 # redefinition below, so we need to load it upfront. The reason is that if
 # Bundler monkeypatches are loaded before RubyGems activates an executable (for
@@ -17,10 +15,6 @@
 # `Gem::Source` from the redefined `Gem::Specification#source`.
 require "rubygems/source"
 
-require_relative "match_metadata"
-require_relative "force_platform"
-require_relative "match_platform"
-
 # Cherry-pick fixes to `Gem.ruby_version` to be useful for modern Bundler
 # versions and ignore patchlevels
 # (https://github.com/rubygems/rubygems/pull/5472,
@@ -31,7 +25,12 @@
 end
 
 module Gem
+  require "rubygems/specification"
+
   class Specification
+    require_relative "match_metadata"
+    require_relative "match_platform"
+
     include ::Bundler::MatchMetadata
     include ::Bundler::MatchPlatform
 
@@ -148,17 +147,23 @@ def dependencies_to_gemfile(dependencies, group = nil)
 
   module BetterPermissionError
     def data
+      require_relative "shared_helpers"
+
       Bundler::SharedHelpers.filesystem_access(loaded_from, :read) do
         super
       end
     end
   end
 
+  require "rubygems/stub_specification"
+
   class StubSpecification
     prepend BetterPermissionError
   end
 
   class Dependency
+    require_relative "force_platform"
+
     include ::Bundler::ForcePlatform
 
     attr_accessor :source, :groups

From 69c87619bd7a69936c44cc0d323b11148400e894 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Fri, 10 May 2024 16:14:26 +0200
Subject: [PATCH 003/242] [rubygems/rubygems] Avoid standard requires while
 loading shared helpers

We should make sure Bundler does not trigger RubyGems require logic for
gem activation until it had the chance to register its own monkeypatches
to RubyGems.

https://github.com/rubygems/rubygems/commit/fbd2ff86b9
---
 lib/bundler/constants.rb            |  2 ++
 lib/bundler/rubygems_integration.rb |  6 ++----
 lib/bundler/shared_helpers.rb       | 10 ++++++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/lib/bundler/constants.rb b/lib/bundler/constants.rb
index de9698b577e41b..bcbd228b187650 100644
--- a/lib/bundler/constants.rb
+++ b/lib/bundler/constants.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rbconfig"
+
 module Bundler
   WINDOWS = RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
   FREEBSD = RbConfig::CONFIG["host_os"].to_s.include?("bsd")
diff --git a/lib/bundler/rubygems_integration.rb b/lib/bundler/rubygems_integration.rb
index 494030eab22846..6980b32236e503 100644
--- a/lib/bundler/rubygems_integration.rb
+++ b/lib/bundler/rubygems_integration.rb
@@ -4,9 +4,7 @@
 
 module Bundler
   class RubygemsIntegration
-    require "monitor"
-
-    EXT_LOCK = Monitor.new
+    autoload :Monitor, "monitor"
 
     def initialize
       @replaced_methods = {}
@@ -173,7 +171,7 @@ def ui=(obj)
     end
 
     def ext_lock
-      EXT_LOCK
+      @ext_lock ||= Monitor.new
     end
 
     def spec_from_gem(path)
diff --git a/lib/bundler/shared_helpers.rb b/lib/bundler/shared_helpers.rb
index 78760e6fa48c64..28f0cdff192c66 100644
--- a/lib/bundler/shared_helpers.rb
+++ b/lib/bundler/shared_helpers.rb
@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "rbconfig"
-
 require_relative "version"
-require_relative "constants"
 require_relative "rubygems_integration"
 require_relative "current_ruby"
 
 module Bundler
+  autoload :WINDOWS, File.expand_path("constants", __dir__)
+  autoload :FREEBSD, File.expand_path("constants", __dir__)
+  autoload :NULL, File.expand_path("constants", __dir__)
+
   module SharedHelpers
+    autoload :Pathname, "pathname"
+
     def root
       gemfile = find_gemfile
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile

From 899568cce9f2929c765738bf52fcadaead953187 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 15:25:26 +0200
Subject: [PATCH 004/242] [rubygems/rubygems] Fix error when Bundler
 installation is corrupted

If one upgrades the default copy of Bundler through `gem update
--system`, and then reinstalls Ruby without removing the previous copy.
Then the new installation will have a correct default bundler gemspec,
but a higher copy installed in site_dir.

This causes a crash when running Bundler and prints the bug report
template.

This could probably be fixed in Ruby install script, by removing any
previous Bundler default copies, but if the problem is already there, I
think it's best to print a proper user error.

https://github.com/rubygems/rubygems/commit/ada6de765d
---
 lib/bundler/errors.rb                 | 14 +++++++++++++
 lib/bundler/source/metadata.rb        |  2 ++
 spec/bundler/commands/install_spec.rb | 29 +++++++++++++++++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/lib/bundler/errors.rb b/lib/bundler/errors.rb
index b6a11cc7219518..c29b1bfed89122 100644
--- a/lib/bundler/errors.rb
+++ b/lib/bundler/errors.rb
@@ -230,4 +230,18 @@ def message
 
     status_code(38)
   end
+
+  class CorruptBundlerInstallError < BundlerError
+    def initialize(loaded_spec)
+      @loaded_spec = loaded_spec
+    end
+
+    def message
+      "The running version of Bundler (#{Bundler::VERSION}) does not match the version of the specification installed for it (#{@loaded_spec.version}). " \
+      "This can be caused by reinstalling Ruby without removing previous installation, leaving around an upgraded default version of Bundler. " \
+      "Reinstalling Ruby from scratch should fix the problem."
+    end
+
+    status_code(39)
+  end
 end
diff --git a/lib/bundler/source/metadata.rb b/lib/bundler/source/metadata.rb
index 4d27761365385e..6b05e177271be1 100644
--- a/lib/bundler/source/metadata.rb
+++ b/lib/bundler/source/metadata.rb
@@ -11,6 +11,8 @@ def specs
           end
 
           if local_spec = Gem.loaded_specs["bundler"]
+            raise CorruptBundlerInstallError.new(local_spec) if local_spec.version.to_s != Bundler::VERSION
+
             idx << local_spec
           else
             idx << Gem::Specification.new do |s|
diff --git a/spec/bundler/commands/install_spec.rb b/spec/bundler/commands/install_spec.rb
index 1e57414377e76f..edc5887d7bceda 100644
--- a/spec/bundler/commands/install_spec.rb
+++ b/spec/bundler/commands/install_spec.rb
@@ -1407,4 +1407,33 @@ def run
       expect(bundled_app(".bundle/config")).not_to exist
     end
   end
+
+  context "when bundler installation is corrupt" do
+    before do
+      system_gems "bundler-9.99.8"
+
+      replace_version_file("9.99.9", dir: system_gem_path("gems/bundler-9.99.8"))
+    end
+
+    it "shows a proper error" do
+      lockfile <<~L
+        GEM
+          remote: #{file_uri_for(gem_repo1)}/
+          specs:
+
+        PLATFORMS
+          #{lockfile_platforms}
+
+        DEPENDENCIES
+
+        BUNDLED WITH
+           9.99.8
+      L
+
+      install_gemfile "source \"#{file_uri_for(gem_repo1)}\"", env: { "BUNDLER_VERSION" => "9.99.8" }, raise_on_error: false
+
+      expect(err).not_to include("ERROR REPORT TEMPLATE")
+      expect(err).to include("The running version of Bundler (9.99.9) does not match the version of the specification installed for it (9.99.8)")
+    end
+  end
 end

From a86ad47c940dee19bfe74a374c5ac61752026b7c Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 15:56:37 +0200
Subject: [PATCH 005/242] [rubygems/rubygems] Improve plugin removal test

Instead of unit testing the `remove_plugins` method, test the whole
removal process.

https://github.com/rubygems/rubygems/commit/bfdc60af98
---
 test/rubygems/test_gem_uninstaller.rb | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/test/rubygems/test_gem_uninstaller.rb b/test/rubygems/test_gem_uninstaller.rb
index 9e0c1aa3d89397..cd6d560ece1c86 100644
--- a/test/rubygems/test_gem_uninstaller.rb
+++ b/test/rubygems/test_gem_uninstaller.rb
@@ -188,20 +188,29 @@ def test_remove_plugins
     refute File.exist?(plugin_path), "plugin not removed"
   end
 
-  def test_remove_plugins_with_install_dir
+  def test_uninstall_with_install_dir_removes_plugins
     write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
       io.write "# do nothing"
     end
 
     @spec.files += %w[lib/rubygems_plugin.rb]
 
-    Gem::Installer.at(Gem::Package.build(@spec), force: true).install
+    package = Gem::Package.build(@spec)
+
+    Gem::Installer.at(package, force: true).install
 
     plugin_path = File.join Gem.plugindir, "a_plugin.rb"
     assert File.exist?(plugin_path), "plugin not written"
 
-    Dir.mkdir "#{@gemhome}2"
-    Gem::Uninstaller.new(nil, install_dir: "#{@gemhome}2").remove_plugins @spec
+    install_dir = "#{@gemhome}2"
+
+    Gem::Installer.at(package, force: true, install_dir: install_dir).install
+
+    install_dir_plugin_path = File.join install_dir, "plugins/a_plugin.rb"
+    assert File.exist?(install_dir_plugin_path), "plugin not written"
+
+    Gem::Specification.dirs = [install_dir]
+    Gem::Uninstaller.new(@spec.name, executables: true, install_dir: install_dir).uninstall
 
     assert File.exist?(plugin_path), "plugin unintentionally removed"
   end

From 5880103450faf26da193ac914421957e37d71604 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ondruch?= <vondruch@redhat.com>
Date: Mon, 13 Mar 2023 14:32:19 +0100
Subject: [PATCH 006/242] [rubygems/rubygems] Use spec.base_dir to remove
 plugins

The plugin loader from `@gem_home` was removed during uninstallation.
However, this could leave behind the plugins for `--user-install`
installed gems.

Use `Gem::Specifictaions#base_dir` instead. This ensures that the plugin
loader for associated .gemspec is uninstalled.

https://github.com/rubygems/rubygems/commit/6047f78210
---
 lib/rubygems/uninstaller.rb           |  9 ++++++---
 test/rubygems/test_gem_uninstaller.rb | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb
index c96df2a08536bb..f4202caa0a5a0f 100644
--- a/lib/rubygems/uninstaller.rb
+++ b/lib/rubygems/uninstaller.rb
@@ -50,7 +50,6 @@ def initialize(gem, options = {})
     @gem                = gem
     @version            = options[:version] || Gem::Requirement.default
     @gem_home           = File.realpath(options[:install_dir] || Gem.dir)
-    @plugins_dir        = Gem.plugindir(@gem_home)
     @force_executables  = options[:executables]
     @force_all          = options[:all]
     @force_ignore       = options[:ignore]
@@ -284,7 +283,7 @@ def remove(spec)
   def remove_plugins(spec) # :nodoc:
     return if spec.plugins.empty?
 
-    remove_plugins_for(spec, @plugins_dir)
+    remove_plugins_for(spec, plugin_dir_for(spec))
   end
 
   ##
@@ -294,7 +293,7 @@ def regenerate_plugins
     latest = Gem::Specification.latest_spec_for(@spec.name)
     return if latest.nil?
 
-    regenerate_plugins_for(latest, @plugins_dir)
+    regenerate_plugins_for(latest, plugin_dir_for(@spec))
   end
 
   ##
@@ -406,4 +405,8 @@ def warn_cannot_uninstall_default_gems(specs)
       say "Gem #{spec.full_name} cannot be uninstalled because it is a default gem"
     end
   end
+
+  def plugin_dir_for(spec)
+    Gem.plugindir(spec.base_dir)
+  end
 end
diff --git a/test/rubygems/test_gem_uninstaller.rb b/test/rubygems/test_gem_uninstaller.rb
index cd6d560ece1c86..20a0005341475c 100644
--- a/test/rubygems/test_gem_uninstaller.rb
+++ b/test/rubygems/test_gem_uninstaller.rb
@@ -215,6 +215,25 @@ def test_uninstall_with_install_dir_removes_plugins
     assert File.exist?(plugin_path), "plugin unintentionally removed"
   end
 
+  def test_remove_plugins_user_installed
+    write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
+      io.write "# do nothing"
+    end
+
+    @spec.files += %w[lib/rubygems_plugin.rb]
+
+    Gem::Installer.at(Gem::Package.build(@spec), force: true, user_install: true).install
+
+    plugin_path = File.join Gem.user_dir, "plugins/a_plugin.rb"
+    assert File.exist?(plugin_path), "plugin not written"
+
+    Gem::Specification.dirs = [Gem.dir, Gem.user_dir]
+
+    Gem::Uninstaller.new(@spec.name, executables: true, force: true, user_install: true).uninstall
+
+    refute File.exist?(plugin_path), "plugin not removed"
+  end
+
   def test_regenerate_plugins_for
     write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
       io.write "# do nothing"

From 02c8e6583b33c62b4050420234167a467f32fefa Mon Sep 17 00:00:00 2001
From: Samuel Giddins <segiddins@segiddins.me>
Date: Tue, 20 Feb 2024 11:05:30 -0800
Subject: [PATCH 007/242] [rubygems/rubygems] Use a constant empty tar header
 to avoid extra allocations

https://github.com/rubygems/rubygems/commit/716666f65f
---
 lib/rubygems/package/tar_header.rb           | 24 +++++++++++++++----
 test/rubygems/test_gem_package_tar_header.rb | 25 ++++++++++++++++++++
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/lib/rubygems/package/tar_header.rb b/lib/rubygems/package/tar_header.rb
index 087f13f6c9e117..dd5e835a1e59b1 100644
--- a/lib/rubygems/package/tar_header.rb
+++ b/lib/rubygems/package/tar_header.rb
@@ -95,14 +95,14 @@ class Gem::Package::TarHeader
 
   attr_reader(*FIELDS)
 
-  EMPTY_HEADER = ("\0" * 512).freeze # :nodoc:
+  EMPTY_HEADER = ("\0" * 512).b.freeze # :nodoc:
 
   ##
   # Creates a tar header from IO +stream+
 
   def self.from(stream)
     header = stream.read 512
-    empty = (header == EMPTY_HEADER)
+    return EMPTY if header == EMPTY_HEADER
 
     fields = header.unpack UNPACK_FORMAT
 
@@ -123,7 +123,7 @@ def self.from(stream)
         devminor: strict_oct(fields.shift),
         prefix: fields.shift,
 
-        empty: empty
+        empty: false
   end
 
   def self.strict_oct(str)
@@ -172,6 +172,22 @@ def initialize(vals)
     @empty = vals[:empty]
   end
 
+  EMPTY = new({ # :nodoc:
+    checksum: 0,
+    gname: "",
+    linkname: "",
+    magic: "",
+    mode: 0,
+    name: "",
+    prefix: "",
+    size: 0,
+    uname: "",
+    version: 0,
+
+    empty: true,
+  }).freeze
+  private_constant :EMPTY
+
   ##
   # Is the tar entry empty?
 
@@ -241,7 +257,7 @@ def header(checksum = @checksum)
 
     header = header.pack PACK_FORMAT
 
-    header << ("\0" * ((512 - header.size) % 512))
+    header.ljust 512, "\0"
   end
 
   def oct(num, len)
diff --git a/test/rubygems/test_gem_package_tar_header.rb b/test/rubygems/test_gem_package_tar_header.rb
index 4469750f9a5657..a3f95bb7704f91 100644
--- a/test/rubygems/test_gem_package_tar_header.rb
+++ b/test/rubygems/test_gem_package_tar_header.rb
@@ -99,6 +99,31 @@ def test_empty_eh
     assert_empty @tar_header
   end
 
+  def test_empty
+    @tar_header = Gem::Package::TarHeader.from(StringIO.new(Gem::Package::TarHeader::EMPTY_HEADER))
+
+    assert_empty @tar_header
+    assert_equal Gem::Package::TarHeader.new(
+      checksum: 0,
+      devmajor: 0,
+      devminor: 0,
+      empty: true,
+      gid: 0,
+      gname: "",
+      linkname: "",
+      magic: "",
+      mode: 0,
+      mtime: 0,
+      name: "",
+      prefix: "",
+      size: 0,
+      typeflag: "0",
+      uid: 0,
+      uname: "",
+      version: 0,
+    ), @tar_header
+  end
+
   def test_equals2
     assert_equal @tar_header, @tar_header
     assert_equal @tar_header, @tar_header.dup

From e6340258f88064cabba5150cfef1f8898f6aa9d8 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 13 May 2024 11:26:39 -0400
Subject: [PATCH 008/242] [ruby/prism] Autoload newlines and comment visitors

Having the @newline instance variable in every node adds up, and
since it is so rarely used, we only want to add it when necessary.

Moving this into an autoloaded file and moving the instance variable
out of the default initializers reduces allocated memory because the
nodes are now smaller and some fit into the compact list. On my
machine, I'm seeing about an 8% drop.

https://github.com/ruby/prism/commit/eea92c07d2
---
 lib/prism.rb                                  |   2 -
 lib/prism/parse_result.rb                     |  17 +++
 lib/prism/parse_result/comments.rb            |   7 --
 lib/prism/parse_result/newlines.rb            | 111 ++++++++++++++++--
 .../lib/prism/inspect_visitor.rb.erb          |   7 +-
 prism/templates/lib/prism/node.rb.erb         |  32 -----
 6 files changed, 118 insertions(+), 58 deletions(-)

diff --git a/lib/prism.rb b/lib/prism.rb
index 19774538e7a9e1..2bb7f79bf644d0 100644
--- a/lib/prism.rb
+++ b/lib/prism.rb
@@ -71,8 +71,6 @@ def self.load(source, serialized)
 require_relative "prism/node"
 require_relative "prism/node_ext"
 require_relative "prism/parse_result"
-require_relative "prism/parse_result/comments"
-require_relative "prism/parse_result/newlines"
 
 # This is a Ruby implementation of the prism parser. If we're running on CRuby
 # and we haven't explicitly set the PRISM_FFI_BACKEND environment variable, then
diff --git a/lib/prism/parse_result.rb b/lib/prism/parse_result.rb
index 63cc72a96640b2..798fde09e5a7c8 100644
--- a/lib/prism/parse_result.rb
+++ b/lib/prism/parse_result.rb
@@ -574,6 +574,12 @@ def failure?
 
   # This is a result specific to the `parse` and `parse_file` methods.
   class ParseResult < Result
+    autoload :Comments, "prism/parse_result/comments"
+    autoload :Newlines, "prism/parse_result/newlines"
+
+    private_constant :Comments
+    private_constant :Newlines
+
     # The syntax tree that was parsed from the source code.
     attr_reader :value
 
@@ -587,6 +593,17 @@ def initialize(value, comments, magic_comments, data_loc, errors, warnings, sour
     def deconstruct_keys(keys)
       super.merge!(value: value)
     end
+
+    # Attach the list of comments to their respective locations in the tree.
+    def attach_comments!
+      Comments.new(self).attach! # steep:ignore
+    end
+
+    # Walk the tree and mark nodes that are on a new line, loosely emulating
+    # the behavior of CRuby's `:line` tracepoint event.
+    def mark_newlines!
+      value.accept(Newlines.new(source.offsets.size)) # steep:ignore
+    end
   end
 
   # This is a result specific to the `lex` and `lex_file` methods.
diff --git a/lib/prism/parse_result/comments.rb b/lib/prism/parse_result/comments.rb
index 3fa0603d74ce71..22c4148b2c168c 100644
--- a/lib/prism/parse_result/comments.rb
+++ b/lib/prism/parse_result/comments.rb
@@ -183,12 +183,5 @@ def nearest_targets(node, comment)
         [preceding, NodeTarget.new(node), following]
       end
     end
-
-    private_constant :Comments
-
-    # Attach the list of comments to their respective locations in the tree.
-    def attach_comments!
-      Comments.new(self).attach! # steep:ignore
-    end
   end
 end
diff --git a/lib/prism/parse_result/newlines.rb b/lib/prism/parse_result/newlines.rb
index 4a8151cc09a090..cc1343dfdacc28 100644
--- a/lib/prism/parse_result/newlines.rb
+++ b/lib/prism/parse_result/newlines.rb
@@ -17,21 +17,26 @@ class ParseResult < Result
     # Note that the logic in this file should be kept in sync with the Java
     # MarkNewlinesVisitor, since that visitor is responsible for marking the
     # newlines for JRuby/TruffleRuby.
+    #
+    # This file is autoloaded only when `mark_newlines!` is called, so the
+    # re-opening of the various nodes in this file will only be performed in
+    # that case. We do that to avoid storing the extra `@newline` instance
+    # variable on every node if we don't need it.
     class Newlines < Visitor
       # Create a new Newlines visitor with the given newline offsets.
-      def initialize(newline_marked)
-        @newline_marked = newline_marked
+      def initialize(lines)
+        @lines = Array.new(1 + lines, false)
       end
 
       # Permit block/lambda nodes to mark newlines within themselves.
       def visit_block_node(node)
-        old_newline_marked = @newline_marked
-        @newline_marked = Array.new(old_newline_marked.size, false)
+        old_lines = @lines
+        @lines = Array.new(old_lines.size, false)
 
         begin
           super(node)
         ensure
-          @newline_marked = old_newline_marked
+          @lines = old_lines
         end
       end
 
@@ -39,7 +44,7 @@ def visit_block_node(node)
 
       # Mark if/unless nodes as newlines.
       def visit_if_node(node)
-        node.set_newline_flag(@newline_marked)
+        node.newline!(@lines)
         super(node)
       end
 
@@ -48,17 +53,101 @@ def visit_if_node(node)
       # Permit statements lists to mark newlines within themselves.
       def visit_statements_node(node)
         node.body.each do |child|
-          child.set_newline_flag(@newline_marked)
+          child.newline!(@lines)
         end
         super(node)
       end
     end
+  end
+
+  class Node
+    def newline? # :nodoc:
+      @newline ? true : false
+    end
+
+    def newline!(lines) # :nodoc:
+      line = location.start_line
+      unless lines[line]
+        lines[line] = true
+        @newline = true
+      end
+    end
+  end
+
+  class BeginNode < Node
+    def newline!(lines) # :nodoc:
+      # Never mark BeginNode with a newline flag, mark children instead.
+    end
+  end
+
+  class ParenthesesNode < Node
+    def newline!(lines) # :nodoc:
+      # Never mark ParenthesesNode with a newline flag, mark children instead.
+    end
+  end
+
+  class IfNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class UnlessNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class UntilNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class WhileNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class RescueModifierNode < Node
+    def newline!(lines) # :nodoc:
+      expression.newline!(lines)
+    end
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
+
+  class InterpolatedStringNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
 
-    private_constant :Newlines
+  class InterpolatedSymbolNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
 
-    # Walk the tree and mark nodes that are on a new line.
-    def mark_newlines!
-      value.accept(Newlines.new(Array.new(1 + source.offsets.size, false))) # steep:ignore
+  class InterpolatedXStringNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
     end
   end
 end
diff --git a/prism/templates/lib/prism/inspect_visitor.rb.erb b/prism/templates/lib/prism/inspect_visitor.rb.erb
index 8e7902f0f1ff2d..9328da636b0739 100644
--- a/prism/templates/lib/prism/inspect_visitor.rb.erb
+++ b/prism/templates/lib/prism/inspect_visitor.rb.erb
@@ -116,13 +116,8 @@ module Prism
 
     # Compose a header for the given node.
     def inspect_node(name, node)
-      result = +"@ #{name} ("
-
       location = node.location
-      result << "location: (#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column})"
-      result << ", newline: true" if node.newline?
-
-      result << ")\n"
+      "@ #{name} (location: (#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column}))\n"
     end
 
     # Compose a string representing the given inner location field.
diff --git a/prism/templates/lib/prism/node.rb.erb b/prism/templates/lib/prism/node.rb.erb
index 50e622a8d12ca8..f0ce226defcff9 100644
--- a/prism/templates/lib/prism/node.rb.erb
+++ b/prism/templates/lib/prism/node.rb.erb
@@ -28,18 +28,6 @@ module Prism
       location.is_a?(Location) ? location.end_offset : ((location >> 32) + (location & 0xFFFFFFFF))
     end
 
-    def newline? # :nodoc:
-      @newline ? true : false
-    end
-
-    def set_newline_flag(newline_marked) # :nodoc:
-      line = location.start_line
-      unless newline_marked[line]
-        newline_marked[line] = true
-        @newline = true
-      end
-    end
-
     # Returns all of the lines of the source code associated with this node.
     def source_lines
       location.source_lines
@@ -181,7 +169,6 @@ module Prism
     # def initialize: (<%= (node.fields.map { |field| "#{field.rbs_class} #{field.name}" } + ["Location location"]).join(", ") %>) -> void
     def initialize(source, <%= (node.fields.map(&:name) + ["location"]).join(", ") %>)
       @source = source
-      @newline = false
       @location = location
       <%- node.fields.each do |field| -%>
       <%- if Prism::Template::CHECK_FIELD_KIND && field.respond_to?(:check_field_kind) -%>
@@ -195,25 +182,6 @@ module Prism
     def accept(visitor)
       visitor.visit_<%= node.human %>(self)
     end
-    <%- if node.newline == false -%>
-
-    def set_newline_flag(newline_marked) # :nodoc:
-      # Never mark <%= node.name %> with a newline flag, mark children instead
-    end
-    <%- elsif node.newline.is_a?(String) -%>
-
-    def set_newline_flag(newline_marked) # :nodoc:
-      <%- field = node.fields.find { |f| f.name == node.newline } or raise node.newline -%>
-      <%- case field -%>
-      <%- when Prism::Template::NodeField -%>
-      <%= field.name %>.set_newline_flag(newline_marked)
-      <%- when Prism::Template::NodeListField -%>
-      first = <%= field.name %>.first
-      first.set_newline_flag(newline_marked) if first
-      <%- else raise field.class.name -%>
-      <%- end -%>
-    end
-    <%- end -%>
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes

From 5931f857abf704c6fc62a93d2fc933b13950392d Mon Sep 17 00:00:00 2001
From: Koichi ITO <koic.ito@gmail.com>
Date: Mon, 13 May 2024 16:56:01 +0900
Subject: [PATCH 009/242] [ruby/prism] Add error handling for missing `parser`
 gem in `Prism::Translation`

Resolves https://github.com/ruby/prism/pull/2803.

This PR adds error handling for missing `parser` gem in `Prism::Translation`.

The `parser` gem is a required runtime dependency when using `Prism::Translation::Parser`.
But it is not required for other uses of Prism. To avoid unnecessary dependencies,
it is not added as a `runtime_dependency` in the prism.gemspec. Instead, if the dependency is missing,
instructions are given to add it to Gemfile.

## Before

```console
$ bundle exec ruby -e 'require "prism"; require "prism/translation/parser33"'
/Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `require': cannot load such file -- parser (LoadError)
from /Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `block (2 levels) in replace_require'
from /Users/koic/src/github.com/ruby/prism/lib/prism/translation/parser.rb:3:in `<top (required)>'
from /Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `require'
from /Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `block (2 levels) in replace_require'
from /Users/koic/src/github.com/ruby/prism/lib/prism/translation/parser33.rb:6:in `<module:Translation>'
from /Users/koic/src/github.com/ruby/prism/lib/prism/translation/parser33.rb:4:in `<module:Prism>'
from /Users/koic/src/github.com/ruby/prism/lib/prism/translation/parser33.rb:3:in `<top (required)>'
from /Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `require'
from /Users/koic/.rbenv/versions/3.3.1/lib/ruby/3.3.0/bundled_gems.rb:74:in `block (2 levels) in replace_require'
from -e:1:in `<main>'
```

## After

```console
$ bundle exec ruby -e 'require "prism"; require "prism/translation/parser33"'
Error: Unable to load parser. Add `gem "parser"` to your Gemfile.
```

https://github.com/ruby/prism/commit/4880aec22d
---
 lib/prism/translation/parser.rb | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/prism/translation/parser.rb b/lib/prism/translation/parser.rb
index 193bbae406e536..8052e38570c8f8 100644
--- a/lib/prism/translation/parser.rb
+++ b/lib/prism/translation/parser.rb
@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require "parser"
+begin
+  require "parser"
+rescue LoadError => e
+  warn 'Error: Unable to load parser. Add `gem "parser"` to your Gemfile.'
+  exit!
+end
 
 module Prism
   module Translation

From b5e53e2f32e19e826eacbf9e2e301b1deae146df Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 13 May 2024 12:31:47 -0400
Subject: [PATCH 010/242] [ruby/prism] Rescue LoadError for ruby_parser as well

https://github.com/ruby/prism/commit/d4eb13e703
---
 lib/prism/translation/parser.rb      | 6 +++---
 lib/prism/translation/ruby_parser.rb | 7 ++++++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/prism/translation/parser.rb b/lib/prism/translation/parser.rb
index 8052e38570c8f8..3748fc896e9826 100644
--- a/lib/prism/translation/parser.rb
+++ b/lib/prism/translation/parser.rb
@@ -2,9 +2,9 @@
 
 begin
   require "parser"
-rescue LoadError => e
-  warn 'Error: Unable to load parser. Add `gem "parser"` to your Gemfile.'
-  exit!
+rescue LoadError
+  warn(%q{Error: Unable to load parser. Add `gem "parser"` to your Gemfile.})
+  exit(1)
 end
 
 module Prism
diff --git a/lib/prism/translation/ruby_parser.rb b/lib/prism/translation/ruby_parser.rb
index d01a762a033b24..43aac23be7b7dd 100644
--- a/lib/prism/translation/ruby_parser.rb
+++ b/lib/prism/translation/ruby_parser.rb
@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require "ruby_parser"
+begin
+  require "ruby_parser"
+rescue LoadError
+  warn(%q{Error: Unable to load ruby_parser. Add `gem "ruby_parser"` to your Gemfile.})
+  exit(1)
+end
 
 module Prism
   module Translation

From 22dab739714208bde73a7c86ebcc2667e534b39e Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 15:02:43 +0200
Subject: [PATCH 011/242] [rubygems/rubygems] Don't depend on Pathname
 unnecessarily

https://github.com/rubygems/rubygems/commit/8c8aaecc48
---
 lib/bundler/rubygems_ext.rb | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/bundler/rubygems_ext.rb b/lib/bundler/rubygems_ext.rb
index 0cd94d60ce6e9c..fa61664a90bc67 100644
--- a/lib/bundler/rubygems_ext.rb
+++ b/lib/bundler/rubygems_ext.rb
@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "pathname"
-
 require "rubygems" unless defined?(Gem)
 
 # We can't let `Gem::Source` be autoloaded in the `Gem::Specification#source`
@@ -47,7 +45,7 @@ def source
 
     def full_gem_path
       if source.respond_to?(:root)
-        Pathname.new(loaded_from).dirname.expand_path(source.root).to_s
+        File.expand_path(File.dirname(loaded_from), source.root)
       else
         rg_full_gem_path
       end

From d1c172dfd0296efda404e85bfc42cd8720b65cea Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 15:03:13 +0200
Subject: [PATCH 012/242] [rubygems/rubygems] Don't load `SharedHelpers`
 unnecessarily

https://github.com/rubygems/rubygems/commit/de4650f629
---
 lib/bundler/rubygems_ext.rb | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/lib/bundler/rubygems_ext.rb b/lib/bundler/rubygems_ext.rb
index fa61664a90bc67..14b870321313c0 100644
--- a/lib/bundler/rubygems_ext.rb
+++ b/lib/bundler/rubygems_ext.rb
@@ -145,11 +145,9 @@ def dependencies_to_gemfile(dependencies, group = nil)
 
   module BetterPermissionError
     def data
-      require_relative "shared_helpers"
-
-      Bundler::SharedHelpers.filesystem_access(loaded_from, :read) do
-        super
-      end
+      super
+    rescue Errno::EACCES
+      raise Bundler::PermissionError.new(loaded_from, :read)
     end
   end
 

From 5319587ac32e168dbaba452585e3f3861082ee8d Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 15:03:32 +0200
Subject: [PATCH 013/242] [rubygems/rubygems] Restore previous way of loading
 monitor

I'm not sure why but this particular change seems to have introduced
some flaky test failures. So I'll revert it.

https://github.com/rubygems/rubygems/commit/668488014b
---
 lib/bundler/rubygems_integration.rb | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/bundler/rubygems_integration.rb b/lib/bundler/rubygems_integration.rb
index 6980b32236e503..494030eab22846 100644
--- a/lib/bundler/rubygems_integration.rb
+++ b/lib/bundler/rubygems_integration.rb
@@ -4,7 +4,9 @@
 
 module Bundler
   class RubygemsIntegration
-    autoload :Monitor, "monitor"
+    require "monitor"
+
+    EXT_LOCK = Monitor.new
 
     def initialize
       @replaced_methods = {}
@@ -171,7 +173,7 @@ def ui=(obj)
     end
 
     def ext_lock
-      @ext_lock ||= Monitor.new
+      EXT_LOCK
     end
 
     def spec_from_gem(path)

From 9d01f657b30f51f60ac6dec7fb47d13549d26bcd Mon Sep 17 00:00:00 2001
From: Mari Imaizumi <mariimaizumi5@gmail.com>
Date: Tue, 14 May 2024 10:58:27 +0900
Subject: [PATCH 014/242] [ruby/reline] Implement the undo command
 (https://github.com/ruby/reline/pull/701)

* Refactor send

* Implement the undo command

* Fix @past_lines initialization

* Improve assertion

* Hide to save buffer in insert_pasted_text

* Replace @using_delete_command with @undoing

* Refactor `@past_lines`

https://github.com/ruby/reline/commit/4ab72f9cbd
---
 lib/reline/key_actor/emacs.rb               |  2 +-
 lib/reline/line_editor.rb                   | 61 ++++++++++++++++--
 test/reline/test_key_actor_emacs.rb         | 68 +++++++++++++++++++++
 test/reline/yamatanooroti/test_rendering.rb | 13 ++++
 4 files changed, 138 insertions(+), 6 deletions(-)

diff --git a/lib/reline/key_actor/emacs.rb b/lib/reline/key_actor/emacs.rb
index 9c797ba43e97bc..edd88289a3c940 100644
--- a/lib/reline/key_actor/emacs.rb
+++ b/lib/reline/key_actor/emacs.rb
@@ -63,7 +63,7 @@ class Reline::KeyActor::Emacs < Reline::KeyActor::Base
     #  30 ^^
     :ed_unassigned,
     #  31 ^_
-    :ed_unassigned,
+    :undo,
     #  32 SPACE
     :ed_insert,
     #  33 !
diff --git a/lib/reline/line_editor.rb b/lib/reline/line_editor.rb
index 4c76932c1097a5..23ece602203432 100644
--- a/lib/reline/line_editor.rb
+++ b/lib/reline/line_editor.rb
@@ -4,7 +4,6 @@
 require 'tempfile'
 
 class Reline::LineEditor
-  # TODO: undo
   # TODO: Use "private alias_method" idiom after drop Ruby 2.5.
   attr_reader :byte_pointer
   attr_accessor :confirm_multiline_termination_proc
@@ -251,6 +250,8 @@ def reset_variables(prompt = '', encoding:)
     @resized = false
     @cache = {}
     @rendered_screen = RenderedScreen.new(base_y: 0, lines: [], cursor_y: 0)
+    @past_lines = []
+    @undoing = false
     reset_line
   end
 
@@ -948,7 +949,8 @@ def dialog_proc_scope_completion_journey_data
         unless @waiting_proc
           byte_pointer_diff = @byte_pointer - old_byte_pointer
           @byte_pointer = old_byte_pointer
-          send(@vi_waiting_operator, byte_pointer_diff)
+          method_obj = method(@vi_waiting_operator)
+          wrap_method_call(@vi_waiting_operator, method_obj, byte_pointer_diff)
           cleanup_waiting
         end
       else
@@ -1009,7 +1011,8 @@ def wrap_method_call(method_symbol, method_obj, key, with_operator = false)
       if @vi_waiting_operator
         byte_pointer_diff = @byte_pointer - old_byte_pointer
         @byte_pointer = old_byte_pointer
-        send(@vi_waiting_operator, byte_pointer_diff)
+        method_obj = method(@vi_waiting_operator)
+        wrap_method_call(@vi_waiting_operator, method_obj, byte_pointer_diff)
         cleanup_waiting
       end
       @kill_ring.process
@@ -1106,6 +1109,7 @@ def update(key)
   end
 
   def input_key(key)
+    save_old_buffer
     @config.reset_oneshot_key_bindings
     @dialogs.each do |dialog|
       if key.char.instance_of?(Symbol) and key.char == dialog.name
@@ -1120,7 +1124,6 @@ def input_key(key)
       finish
       return
     end
-    old_lines = @buffer_of_lines.dup
     @first_char = false
     @completion_occurs = false
 
@@ -1134,12 +1137,15 @@ def input_key(key)
       @completion_journey_state = nil
     end
 
+    push_past_lines unless @undoing
+    @undoing = false
+
     if @in_pasting
       clear_dialogs
       return
     end
 
-    modified = old_lines != @buffer_of_lines
+    modified = @old_buffer_of_lines != @buffer_of_lines
     if !@completion_occurs && modified && !@config.disable_completion && @config.autocompletion
       # Auto complete starts only when edited
       process_insert(force: true)
@@ -1148,6 +1154,26 @@ def input_key(key)
     modified
   end
 
+  def save_old_buffer
+    @old_buffer_of_lines = @buffer_of_lines.dup
+    @old_byte_pointer = @byte_pointer.dup
+    @old_line_index = @line_index.dup
+  end
+
+  def push_past_lines
+    if @old_buffer_of_lines != @buffer_of_lines
+      @past_lines.push([@old_buffer_of_lines, @old_byte_pointer, @old_line_index])
+    end
+    trim_past_lines
+  end
+
+  MAX_PAST_LINES = 100
+  def trim_past_lines
+    if @past_lines.size > MAX_PAST_LINES
+      @past_lines.shift
+    end
+  end
+
   def scroll_into_view
     _wrapped_cursor_x, wrapped_cursor_y = wrapped_cursor_position
     if wrapped_cursor_y < screen_scroll_top
@@ -1224,6 +1250,18 @@ def set_current_line(line, byte_pointer = nil)
     process_auto_indent
   end
 
+  def set_current_lines(lines, byte_pointer = nil, line_index = 0)
+    cursor = current_byte_pointer_cursor
+    @buffer_of_lines = lines
+    @line_index = line_index
+    if byte_pointer
+      @byte_pointer = byte_pointer
+    else
+      calculate_nearest_cursor(cursor)
+    end
+    process_auto_indent
+  end
+
   def retrieve_completion_block(set_completion_quote_character = false)
     if Reline.completer_word_break_characters.empty?
       word_break_regexp = nil
@@ -1306,6 +1344,7 @@ def confirm_multiline_termination
   end
 
   def insert_pasted_text(text)
+    save_old_buffer
     pre = @buffer_of_lines[@line_index].byteslice(0, @byte_pointer)
     post = @buffer_of_lines[@line_index].byteslice(@byte_pointer..)
     lines = (pre + text.gsub(/\r\n?/, "\n") + post).split("\n", -1)
@@ -1313,6 +1352,7 @@ def insert_pasted_text(text)
     @buffer_of_lines[@line_index, 1] = lines
     @line_index += lines.size - 1
     @byte_pointer = @buffer_of_lines[@line_index].bytesize - post.bytesize
+    push_past_lines
   end
 
   def insert_text(text)
@@ -2487,4 +2527,15 @@ def finish
   private def vi_editing_mode(key)
     @config.editing_mode = :vi_insert
   end
+
+  private def undo(_key)
+    return if @past_lines.empty?
+
+    @undoing = true
+
+    target_lines, target_cursor_x, target_cursor_y = @past_lines.last
+    set_current_lines(target_lines, target_cursor_x, target_cursor_y)
+
+    @past_lines.pop
+  end
 end
diff --git a/test/reline/test_key_actor_emacs.rb b/test/reline/test_key_actor_emacs.rb
index 409a7334cbbe9d..013ca2f7b36040 100644
--- a/test/reline/test_key_actor_emacs.rb
+++ b/test/reline/test_key_actor_emacs.rb
@@ -1437,4 +1437,72 @@ def test_vi_editing_mode
     @line_editor.__send__(:vi_editing_mode, nil)
     assert(@config.editing_mode_is?(:vi_insert))
   end
+
+  def test_undo
+    input_keys("\C-_", false)
+    assert_line_around_cursor('', '')
+    input_keys("aあb\C-h\C-h\C-h", false)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあb', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('', '')
+  end
+
+  def test_undo_with_cursor_position
+    input_keys("abc\C-b\C-h", false)
+    assert_line_around_cursor('a', 'c')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('ab', 'c')
+    input_keys("あいう\C-b\C-h", false)
+    assert_line_around_cursor('abあ', 'うc')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('abあい', 'うc')
+  end
+
+  def test_undo_with_multiline
+    @line_editor.multiline_on
+    @line_editor.confirm_multiline_termination_proc = proc {}
+    input_keys("1\n2\n3", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(2)
+    assert_line_around_cursor('3', '')
+    input_keys("\C-p\C-h\C-h", false)
+    assert_whole_lines(["1", "3"])
+    assert_line_index(0)
+    assert_line_around_cursor('1', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", ""])
+    assert_line_index(2)
+    assert_line_around_cursor('', '')
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+  end
+
+  def test_undo_with_many_times
+    str = "a" + "b" * 100
+    input_keys(str, false)
+    100.times { input_keys("\C-_", false) }
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+  end
 end
diff --git a/test/reline/yamatanooroti/test_rendering.rb b/test/reline/yamatanooroti/test_rendering.rb
index 9e8d7da78fdfe6..37a1c1a1930907 100644
--- a/test/reline/yamatanooroti/test_rendering.rb
+++ b/test/reline/yamatanooroti/test_rendering.rb
@@ -556,6 +556,19 @@ def test_bracketed_paste
       EOC
     end
 
+    def test_bracketed_paste_with_undo
+      omit if Reline.core.io_gate.win?
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
+      write("abc")
+      write("\e[200~def hoge\r\t3\rend\e[201~")
+      write("\C-_")
+      close
+      assert_screen(<<~EOC)
+        Multiline REPL.
+        prompt> abc
+      EOC
+    end
+
     def test_backspace_until_returns_to_initial
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("ABC")

From b60f09442a0220e2fc053de020fdc58b642f851e Mon Sep 17 00:00:00 2001
From: Andrew Konchin <andry.konchin@gmail.com>
Date: Fri, 10 May 2024 12:28:59 +0300
Subject: [PATCH 015/242] Fix TestPatternMatching#test_deconstruct_keys test

Before the change `C.keys` returned keys captured in some previous test case that by chance captured `nil` value what made this test passed successfully. Now it returns keys captured in this test case.
---
 test/ruby/test_pattern_matching.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/ruby/test_pattern_matching.rb b/test/ruby/test_pattern_matching.rb
index db6ad06b82d12a..cfe3bd1e1939a3 100644
--- a/test/ruby/test_pattern_matching.rb
+++ b/test/ruby/test_pattern_matching.rb
@@ -1331,7 +1331,7 @@ def test_deconstruct_keys
     end
 
     assert_block do
-      case {}
+      case C.new({})
       in {}
         C.keys == nil
       end

From 4a1e4436a99c5794b022f03e8c0589cf8bae1c71 Mon Sep 17 00:00:00 2001
From: Mari Imaizumi <mariimaizumi5@gmail.com>
Date: Tue, 14 May 2024 17:18:28 +0900
Subject: [PATCH 016/242] [ruby/reline] Bump version to 0.5.7
 (https://github.com/ruby/reline/pull/704)

https://github.com/ruby/reline/commit/b9b3d392ff
---
 lib/reline/version.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/reline/version.rb b/lib/reline/version.rb
index ef7d617a4504fe..46613a59520d21 100644
--- a/lib/reline/version.rb
+++ b/lib/reline/version.rb
@@ -1,3 +1,3 @@
 module Reline
-  VERSION = '0.5.6'
+  VERSION = '0.5.7'
 end

From 44f50f41796ee24fbd955fb768ca17f24b99b0ed Mon Sep 17 00:00:00 2001
From: git <svn-admin@ruby-lang.org>
Date: Tue, 14 May 2024 08:19:43 +0000
Subject: [PATCH 017/242] Update default gems list at
 4a1e4436a99c5794b022f03e8c0589 [ci skip]

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 4c950e884f56f1..ce626248a566ad 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -51,7 +51,7 @@ The following default gems are updated.
 * optparse 0.5.0
 * prism 0.29.0
 * rdoc 6.6.3.1
-* reline 0.5.6
+* reline 0.5.7
 * resolv 0.4.0
 * stringio 3.1.1
 * strscan 3.1.1

From 41e6fd066e8ea82c460ba392a1dd55d624a19763 Mon Sep 17 00:00:00 2001
From: Alexander Ross <ross@standout.se>
Date: Tue, 14 May 2024 10:22:36 +0200
Subject: [PATCH 018/242] [DOC] Fix typo in example code for `String#encode`
 method

The example code in the documentation for the `String#encode` method has
a typo in the `fallback` option. The example code uses `h` as the
fallback option, but it should use `hash` instead to match the variable
name in the example code.
---
 doc/encodings.rdoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/encodings.rdoc b/doc/encodings.rdoc
index 97c0d2261600ff..d85099cdbccbba 100644
--- a/doc/encodings.rdoc
+++ b/doc/encodings.rdoc
@@ -419,7 +419,7 @@ These keyword-value pairs specify encoding options:
 
     hash = {"\u3042" => 'xyzzy'}
     hash.default = 'XYZZY'
-    s.encode('ASCII', fallback: h) # => "xyzzyfooXYZZY"
+    s.encode('ASCII', fallback: hash) # => "xyzzyfooXYZZY"
 
     def (fallback = "U+%.4X").escape(x)
       self % x.unpack("U")

From 4dc0b2301806cc5214b4cfc40e300b03e893726f Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Fri, 3 May 2024 23:38:05 +0200
Subject: [PATCH 019/242] [rubygems/rubygems] Remove redundant receivers

https://github.com/rubygems/rubygems/commit/7b71965a70
---
 lib/rubygems/specification.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index a1eaf1248ed6a2..5fedc8bc7963be 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -859,7 +859,7 @@ def self.stubs_for(name)
   # optionally filtering out specs not matching the current platform
   #
   def self.stubs_for_pattern(pattern, match_platform = true) # :nodoc:
-    installed_stubs = installed_stubs(Gem::Specification.dirs, pattern)
+    installed_stubs = installed_stubs(dirs, pattern)
     installed_stubs.select! {|s| Gem::Platform.match_spec? s } if match_platform
     stubs = installed_stubs + default_stubs(pattern)
     stubs = stubs.uniq(&:full_name)
@@ -1125,7 +1125,7 @@ def self.from_yaml(input)
   # +prerelease+ is true.
 
   def self.latest_specs(prerelease = false)
-    _latest_specs Gem::Specification.stubs, prerelease
+    _latest_specs stubs, prerelease
   end
 
   ##

From 8d28e635662a44b8f4a0e6dd6d655e0734f99271 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 17:13:48 +0200
Subject: [PATCH 020/242] [rubygems/rubygems] Simplify test teardown

If we move test directory removal to the very end, I think we should not
leak anything.

https://github.com/rubygems/rubygems/commit/fb3d8944b5
---
 test/rubygems/helper.rb | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/test/rubygems/helper.rb b/test/rubygems/helper.rb
index b90b7f28ebaa3c..771faf6488f3bd 100644
--- a/test/rubygems/helper.rb
+++ b/test/rubygems/helper.rb
@@ -76,8 +76,6 @@ class Gem::TestCase < Test::Unit::TestCase
 
   attr_accessor :uri # :nodoc:
 
-  @@tempdirs = []
-
   def assert_activate(expected, *specs)
     specs.each do |spec|
       case spec
@@ -451,8 +449,6 @@ def teardown
 
     Dir.chdir @current_dir
 
-    FileUtils.rm_rf @tempdir
-
     ENV.replace(@orig_env)
 
     Gem::ConfigFile.send :remove_const, :SYSTEM_WIDE_CONFIG_FILE
@@ -481,12 +477,9 @@ def teardown
 
     @back_ui.close
 
-    refute_directory_exists @tempdir, "may be still in use"
-    ghosts = @@tempdirs.filter_map do |test_name, tempdir|
-      test_name if File.exist?(tempdir)
-    end
-    @@tempdirs << [method_name, @tempdir]
-    assert_empty ghosts
+    FileUtils.rm_rf @tempdir
+
+    refute_directory_exists @tempdir, "#{@tempdir} used by test #{method_name} is still in use"
   end
 
   def credential_setup

From 64542380728b2f0cb0a76a09d08735538350cd9f Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 12:15:44 +0200
Subject: [PATCH 021/242] [rubygems/rubygems] Make `Gem.clear_paths` test less
 implementation dependent

https://github.com/rubygems/rubygems/commit/b545daa95d
---
 test/rubygems/helper.rb               | 10 ++++++++++
 test/rubygems/test_gem.rb             |  5 ++++-
 test/rubygems/test_gem_ci_detector.rb | 14 +-------------
 3 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/test/rubygems/helper.rb b/test/rubygems/helper.rb
index 771faf6488f3bd..856dc535882435 100644
--- a/test/rubygems/helper.rb
+++ b/test/rubygems/helper.rb
@@ -534,6 +534,16 @@ def without_any_upwards_gemfiles
     ENV["BUNDLE_GEMFILE"] = File.join(@tempdir, "Gemfile")
   end
 
+  def with_env(overrides, &block)
+    @orig_env = ENV.to_h
+    ENV.replace(overrides)
+    begin
+      block.call
+    ensure
+      ENV.replace(@orig_env)
+    end
+  end
+
   ##
   # A git_gem is used with a gem dependencies file.  The gem created here
   # has no files, just a gem specification for the given +name+ and +version+.
diff --git a/test/rubygems/test_gem.rb b/test/rubygems/test_gem.rb
index 3fb66e14072c54..40a473f8d69f8f 100644
--- a/test/rubygems/test_gem.rb
+++ b/test/rubygems/test_gem.rb
@@ -516,7 +516,10 @@ def test_self_clear_paths
 
     Gem.clear_paths
 
-    assert_nil Gem::Specification.send(:class_variable_get, :@@all)
+    with_env("GEM_HOME" => "foo", "GEM_PATH" => "bar") do
+      assert_equal("foo", Gem.dir)
+      assert_equal("bar", Gem.path.first)
+    end
   end
 
   def test_self_configuration
diff --git a/test/rubygems/test_gem_ci_detector.rb b/test/rubygems/test_gem_ci_detector.rb
index 3caefce97d72b1..a28ee49f4b2e55 100644
--- a/test/rubygems/test_gem_ci_detector.rb
+++ b/test/rubygems/test_gem_ci_detector.rb
@@ -3,7 +3,7 @@
 require_relative "helper"
 require "rubygems"
 
-class TestCiDetector < Test::Unit::TestCase
+class TestCiDetector < Gem::TestCase
   def test_ci?
     with_env("FOO" => "bar") { assert_equal(false, Gem::CIDetector.ci?) }
     with_env("CI" => "true") { assert_equal(true, Gem::CIDetector.ci?) }
@@ -29,16 +29,4 @@ def test_ci_strings
       assert_equal(["dsari", "taskcluster"], Gem::CIDetector.ci_strings)
     end
   end
-
-  private
-
-  def with_env(overrides, &block)
-    @orig_env = ENV.to_h
-    ENV.replace(overrides)
-    begin
-      block.call
-    ensure
-      ENV.replace(@orig_env)
-    end
-  end
 end

From 91e387197010586b0fc815f2a83c77832a0f0aa3 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 15:33:44 +0200
Subject: [PATCH 022/242] [rubygems/rubygems] Simplify documentation

I don't think this method is any worse than others, let's only document
what it does.

https://github.com/rubygems/rubygems/commit/dec722187f
---
 lib/rubygems/specification.rb | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index 5fedc8bc7963be..ca418cd394f371 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -923,16 +923,7 @@ def self.all
   end
 
   ##
-  # Sets the known specs to +specs+. Not guaranteed to work for you in
-  # the future. Use at your own risk. Caveat emptor. Doomy doom doom.
-  # Etc etc.
-  #
-  #--
-  # Makes +specs+ the known specs
-  # Listen, time is a river
-  # Winter comes, code breaks
-  #
-  # -- wilsonb
+  # Sets the known specs to +specs+.
 
   def self.all=(specs)
     @@stubs_by_name = specs.group_by(&:name)

From 5628cc1229ea1f53788a263cc0a6ae8df1ad428f Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 15:34:23 +0200
Subject: [PATCH 023/242] [rubygems/rubygems] Add missing docs

Other analog methods are documented, so document this one too.

https://github.com/rubygems/rubygems/commit/76da34d44d
---
 lib/rubygems/specification.rb | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index ca418cd394f371..e369516bdd6060 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -1044,6 +1044,10 @@ def self.find_inactive_by_path(path)
     stub&.to_spec
   end
 
+  ##
+  # Return the best specification that contains the file matching +path+, among
+  # those already activated.
+
   def self.find_active_stub_by_path(path)
     stub = @@active_stub_with_requirable_file[path] ||= stubs.find do |s|
       s.activated? && s.contains_requirable_file?(path)

From c219ee00b446fb22657031aa4a47b9daf72d514c Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 15:36:57 +0200
Subject: [PATCH 024/242] [rubygems/rubygems] Fix typo in attribute
 documentation

https://github.com/rubygems/rubygems/commit/8c9807092c
---
 lib/rubygems/uninstaller.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb
index f4202caa0a5a0f..7dad521a93b9df 100644
--- a/lib/rubygems/uninstaller.rb
+++ b/lib/rubygems/uninstaller.rb
@@ -32,7 +32,7 @@ class Gem::Uninstaller
   attr_reader :bin_dir
 
   ##
-  # The gem repository the gem will be installed into
+  # The gem repository the gem will be uninstalled from
 
   attr_reader :gem_home
 

From bd8423616947738d2efb3602791db91587b822bb Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 15:41:42 +0200
Subject: [PATCH 025/242] [rubygems/rubygems] Extract a
 `Gem::SpecificationRecord` class

This class handles all logic to handle the list of specifications, given
a set of GEM_PATH directories. Makes `Gem::Specification` has less
responsibilities and will help with fixing some bugs next.

https://github.com/rubygems/rubygems/commit/df280dbbed
---
 lib/rubygems/specification.rb           | 107 ++++-----------
 lib/rubygems/specification_record.rb    | 171 ++++++++++++++++++++++++
 test/rubygems/test_gem_specification.rb |  11 +-
 3 files changed, 202 insertions(+), 87 deletions(-)
 create mode 100644 lib/rubygems/specification_record.rb

diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index e369516bdd6060..e27901923e772d 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -11,6 +11,7 @@
 require_relative "basic_specification"
 require_relative "stub_specification"
 require_relative "platform"
+require_relative "specification_record"
 require_relative "util/list"
 
 require "rbconfig"
@@ -179,19 +180,9 @@ class Gem::Specification < Gem::BasicSpecification
     @@default_value[k].nil?
   end
 
-  def self.clear_specs # :nodoc:
-    @@all = nil
-    @@stubs = nil
-    @@stubs_by_name = {}
-    @@spec_with_requirable_file = {}
-    @@active_stub_with_requirable_file = {}
-  end
-  private_class_method :clear_specs
-
-  clear_specs
-
   # Sentinel object to represent "not found" stubs
   NOT_FOUND = Struct.new(:to_spec, :this).new # :nodoc:
+  deprecate_constant :NOT_FOUND
 
   # Tracking removed method calls to warn users during build time.
   REMOVED_METHODS = [:rubyforge_project=, :mark_version].freeze # :nodoc:
@@ -770,7 +761,7 @@ def extensions_dir
   attr_accessor :specification_version
 
   def self._all # :nodoc:
-    @@all ||= Gem.loaded_specs.values | stubs.map(&:to_spec)
+    specification_record.all
   end
 
   def self.clear_load_cache # :nodoc:
@@ -788,26 +779,9 @@ def self.each_gemspec(dirs) # :nodoc:
     end
   end
 
-  def self.gemspec_stubs_in(dir, pattern)
+  def self.gemspec_stubs_in(dir, pattern) # :nodoc:
     Gem::Util.glob_files_in_dir(pattern, dir).map {|path| yield path }.select(&:valid?)
   end
-  private_class_method :gemspec_stubs_in
-
-  def self.installed_stubs(dirs, pattern)
-    map_stubs(dirs, pattern) do |path, base_dir, gems_dir|
-      Gem::StubSpecification.gemspec_stub(path, base_dir, gems_dir)
-    end
-  end
-  private_class_method :installed_stubs
-
-  def self.map_stubs(dirs, pattern) # :nodoc:
-    dirs.flat_map do |dir|
-      base_dir = File.dirname dir
-      gems_dir = File.join base_dir, "gems"
-      gemspec_stubs_in(dir, pattern) {|path| yield path, base_dir, gems_dir }
-    end
-  end
-  private_class_method :map_stubs
 
   def self.each_spec(dirs) # :nodoc:
     each_gemspec(dirs) do |path|
@@ -820,13 +794,7 @@ def self.each_spec(dirs) # :nodoc:
   # Returns a Gem::StubSpecification for every installed gem
 
   def self.stubs
-    @@stubs ||= begin
-      pattern = "*.gemspec"
-      stubs = stubs_for_pattern(pattern, false)
-
-      @@stubs_by_name = stubs.select {|s| Gem::Platform.match_spec? s }.group_by(&:name)
-      stubs
-    end
+    specification_record.stubs
   end
 
   ##
@@ -845,13 +813,7 @@ def self.default_stubs(pattern = "*.gemspec")
   # only returns stubs that match Gem.platforms
 
   def self.stubs_for(name)
-    if @@stubs
-      @@stubs_by_name[name] || []
-    else
-      @@stubs_by_name[name] ||= stubs_for_pattern("#{name}-*.gemspec").select do |s|
-        s.name == name
-      end
-    end
+    specification_record.stubs_for(name)
   end
 
   ##
@@ -859,12 +821,7 @@ def self.stubs_for(name)
   # optionally filtering out specs not matching the current platform
   #
   def self.stubs_for_pattern(pattern, match_platform = true) # :nodoc:
-    installed_stubs = installed_stubs(dirs, pattern)
-    installed_stubs.select! {|s| Gem::Platform.match_spec? s } if match_platform
-    stubs = installed_stubs + default_stubs(pattern)
-    stubs = stubs.uniq(&:full_name)
-    _resort!(stubs)
-    stubs
+    specification_record.stubs_for_pattern(pattern, match_platform)
   end
 
   def self._resort!(specs) # :nodoc:
@@ -893,23 +850,14 @@ def self.load_defaults
   # properly sorted.
 
   def self.add_spec(spec)
-    return if _all.include? spec
-
-    _all << spec
-    stubs << spec
-    (@@stubs_by_name[spec.name] ||= []) << spec
-
-    _resort!(@@stubs_by_name[spec.name])
-    _resort!(stubs)
+    specification_record.add_spec(spec)
   end
 
   ##
   # Removes +spec+ from the known specs.
 
   def self.remove_spec(spec)
-    _all.delete spec.to_spec
-    stubs.delete spec
-    (@@stubs_by_name[spec.name] || []).delete spec
+    specification_record.remove_spec(spec)
   end
 
   ##
@@ -926,15 +874,14 @@ def self.all
   # Sets the known specs to +specs+.
 
   def self.all=(specs)
-    @@stubs_by_name = specs.group_by(&:name)
-    @@all = @@stubs = specs
+    specification_record.all = specs
   end
 
   ##
   # Return full names of all specs in sorted order.
 
   def self.all_names
-    _all.map(&:full_name)
+    specification_record.all_names
   end
 
   ##
@@ -1024,12 +971,7 @@ def self.find_by_full_name(full_name)
   # Return the best specification that contains the file matching +path+.
 
   def self.find_by_path(path)
-    path = path.dup.freeze
-    spec = @@spec_with_requirable_file[path] ||= stubs.find do |s|
-      s.contains_requirable_file? path
-    end || NOT_FOUND
-
-    spec.to_spec
+    specification_record.find_by_path(path)
   end
 
   ##
@@ -1037,11 +979,7 @@ def self.find_by_path(path)
   # amongst the specs that are not activated.
 
   def self.find_inactive_by_path(path)
-    stub = stubs.find do |s|
-      next if s.activated?
-      s.contains_requirable_file? path
-    end
-    stub&.to_spec
+    specification_record.find_inactive_by_path(path)
   end
 
   ##
@@ -1049,11 +987,7 @@ def self.find_inactive_by_path(path)
   # those already activated.
 
   def self.find_active_stub_by_path(path)
-    stub = @@active_stub_with_requirable_file[path] ||= stubs.find do |s|
-      s.activated? && s.contains_requirable_file?(path)
-    end || NOT_FOUND
-
-    stub.this
+    specification_record.find_active_stub_by_path(path)
   end
 
   ##
@@ -1120,14 +1054,14 @@ def self.from_yaml(input)
   # +prerelease+ is true.
 
   def self.latest_specs(prerelease = false)
-    _latest_specs stubs, prerelease
+    specification_record.latest_specs(prerelease)
   end
 
   ##
   # Return the latest installed spec for gem +name+.
 
   def self.latest_spec_for(name)
-    latest_specs(true).find {|installed_spec| installed_spec.name == name }
+    specification_record.latest_spec_for(name)
   end
 
   def self._latest_specs(specs, prerelease = false) # :nodoc:
@@ -1265,7 +1199,7 @@ def self.required_attributes
   def self.reset
     @@dirs = nil
     Gem.pre_reset_hooks.each(&:call)
-    clear_specs
+    @specification_record = nil
     clear_load_cache
     unresolved = unresolved_deps
     unless unresolved.empty?
@@ -1286,6 +1220,13 @@ def self.reset
     Gem.post_reset_hooks.each(&:call)
   end
 
+  ##
+  # Keeps track of all currently known specifications
+
+  def self.specification_record
+    @specification_record ||= Gem::SpecificationRecord.new(dirs)
+  end
+
   # DOC: This method needs documented or nodoc'd
   def self.unresolved_deps
     @unresolved_deps ||= Hash.new {|h, n| h[n] = Gem::Dependency.new n }
diff --git a/lib/rubygems/specification_record.rb b/lib/rubygems/specification_record.rb
new file mode 100644
index 00000000000000..bdce0b3a099184
--- /dev/null
+++ b/lib/rubygems/specification_record.rb
@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Gem
+  class SpecificationRecord
+    def initialize(dirs)
+      @all = nil
+      @stubs = nil
+      @stubs_by_name = {}
+      @spec_with_requirable_file = {}
+      @active_stub_with_requirable_file = {}
+
+      @dirs = dirs
+    end
+
+    # Sentinel object to represent "not found" stubs
+    NOT_FOUND = Struct.new(:to_spec, :this).new
+    private_constant :NOT_FOUND
+
+    ##
+    # Returns the list of all specifications in the record
+
+    def all
+      @all ||= Gem.loaded_specs.values | stubs.map(&:to_spec)
+    end
+
+    ##
+    # Returns a Gem::StubSpecification for every specification in the record
+
+    def stubs
+      @stubs ||= begin
+        pattern = "*.gemspec"
+        stubs = stubs_for_pattern(pattern, false)
+
+        @stubs_by_name = stubs.select {|s| Gem::Platform.match_spec? s }.group_by(&:name)
+        stubs
+      end
+    end
+
+    ##
+    # Returns a Gem::StubSpecification for every specification in the record
+    # named +name+ only returns stubs that match Gem.platforms
+
+    def stubs_for(name)
+      if @stubs
+        @stubs_by_name[name] || []
+      else
+        @stubs_by_name[name] ||= stubs_for_pattern("#{name}-*.gemspec").select do |s|
+          s.name == name
+        end
+      end
+    end
+
+    ##
+    # Finds stub specifications matching a pattern in the record, optionally
+    # filtering out specs not matching the current platform
+
+    def stubs_for_pattern(pattern, match_platform = true)
+      installed_stubs = installed_stubs(pattern)
+      installed_stubs.select! {|s| Gem::Platform.match_spec? s } if match_platform
+      stubs = installed_stubs + Gem::Specification.default_stubs(pattern)
+      stubs = stubs.uniq(&:full_name)
+      Gem::Specification._resort!(stubs)
+      stubs
+    end
+
+    ##
+    # Adds +spec+ to the the record, keeping the collection properly sorted.
+
+    def add_spec(spec)
+      return if all.include? spec
+
+      all << spec
+      stubs << spec
+      (@stubs_by_name[spec.name] ||= []) << spec
+
+      Gem::Specification._resort!(@stubs_by_name[spec.name])
+      Gem::Specification._resort!(stubs)
+    end
+
+    ##
+    # Removes +spec+ from the record.
+
+    def remove_spec(spec)
+      all.delete spec.to_spec
+      stubs.delete spec
+      (@stubs_by_name[spec.name] || []).delete spec
+    end
+
+    ##
+    # Sets the specs known by the record to +specs+.
+
+    def all=(specs)
+      @stubs_by_name = specs.group_by(&:name)
+      @all = @stubs = specs
+    end
+
+    ##
+    # Return full names of all specs in the record in sorted order.
+
+    def all_names
+      all.map(&:full_name)
+    end
+
+    ##
+    # Return the best specification in the record that contains the file matching +path+.
+
+    def find_by_path(path)
+      path = path.dup.freeze
+      spec = @spec_with_requirable_file[path] ||= stubs.find do |s|
+        s.contains_requirable_file? path
+      end || NOT_FOUND
+
+      spec.to_spec
+    end
+
+    ##
+    # Return the best specification in the record that contains the file
+    # matching +path+ amongst the specs that are not activated.
+
+    def find_inactive_by_path(path)
+      stub = stubs.find do |s|
+        next if s.activated?
+        s.contains_requirable_file? path
+      end
+      stub&.to_spec
+    end
+
+    ##
+    # Return the best specification in the record that contains the file
+    # matching +path+, among those already activated.
+
+    def find_active_stub_by_path(path)
+      stub = @active_stub_with_requirable_file[path] ||= stubs.find do |s|
+        s.activated? && s.contains_requirable_file?(path)
+      end || NOT_FOUND
+
+      stub.this
+    end
+
+    ##
+    # Return the latest specs in the record, optionally including prerelease
+    # specs if +prerelease+ is true.
+
+    def latest_specs(prerelease)
+      Gem::Specification._latest_specs stubs, prerelease
+    end
+
+    ##
+    # Return the latest installed spec in the record for gem +name+.
+
+    def latest_spec_for(name)
+      latest_specs(true).find {|installed_spec| installed_spec.name == name }
+    end
+
+    private
+
+    def installed_stubs(pattern)
+      map_stubs(pattern) do |path, base_dir, gems_dir|
+        Gem::StubSpecification.gemspec_stub(path, base_dir, gems_dir)
+      end
+    end
+
+    def map_stubs(pattern)
+      @dirs.flat_map do |dir|
+        base_dir = File.dirname dir
+        gems_dir = File.join base_dir, "gems"
+        Gem::Specification.gemspec_stubs_in(dir, pattern) {|path| yield path, base_dir, gems_dir }
+      end
+    end
+  end
+end
diff --git a/test/rubygems/test_gem_specification.rb b/test/rubygems/test_gem_specification.rb
index f9f063c7976071..9395e34f75188b 100644
--- a/test/rubygems/test_gem_specification.rb
+++ b/test/rubygems/test_gem_specification.rb
@@ -967,7 +967,10 @@ def test_self_remove_spec_removed
 
   def test_self_stubs_for_lazy_loading
     Gem.loaded_specs.clear
-    Gem::Specification.class_variable_set(:@@stubs, nil)
+
+    specification_record = Gem::Specification.specification_record
+
+    specification_record.instance_variable_set(:@stubs, nil)
 
     dir_standard_specs = File.join Gem.dir, "specifications"
 
@@ -975,9 +978,9 @@ def test_self_stubs_for_lazy_loading
     save_gemspec("b-1", "1", dir_standard_specs) {|s| s.name = "b" }
 
     assert_equal ["a-1"], Gem::Specification.stubs_for("a").map(&:full_name)
-    assert_equal 1, Gem::Specification.class_variable_get(:@@stubs_by_name).length
+    assert_equal 1, specification_record.instance_variable_get(:@stubs_by_name).length
     assert_equal ["b-1"], Gem::Specification.stubs_for("b").map(&:full_name)
-    assert_equal 2, Gem::Specification.class_variable_get(:@@stubs_by_name).length
+    assert_equal 2, specification_record.instance_variable_get(:@stubs_by_name).length
 
     assert_equal(
       Gem::Specification.stubs_for("a").map(&:object_id),
@@ -986,7 +989,7 @@ def test_self_stubs_for_lazy_loading
 
     Gem.loaded_specs.delete "a"
     Gem.loaded_specs.delete "b"
-    Gem::Specification.class_variable_set(:@@stubs, nil)
+    specification_record.instance_variable_set(:@stubs, nil)
   end
 
   def test_self_stubs_for_no_lazy_loading_after_all_specs_setup

From 965cb3ab4c659a1be96b6f26df68b75d85585978 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 6 May 2024 21:00:14 +0200
Subject: [PATCH 026/242] [rubygems/rubygems] Fix issue when cleaning up plugin
 stubs

When `gem uninstall <gem> --install-dir <dir>` is run, if the version
removed had a plugin, and that same version happened to also be
installed globally, then the plugin stub would fail to be removed.

https://github.com/rubygems/rubygems/commit/4e2fa0be77
---
 lib/rubygems/specification.rb         |  6 ++----
 lib/rubygems/specification_record.rb  | 10 +++++++++
 lib/rubygems/uninstaller.rb           |  8 ++++---
 test/rubygems/test_gem_uninstaller.rb | 31 +++++++++++++++++++++++++++
 4 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index e27901923e772d..eb846095293ef7 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -906,9 +906,7 @@ def self.attribute_names
   # Return the directories that Specification uses to find specs.
 
   def self.dirs
-    @@dirs ||= Gem.path.collect do |dir|
-      File.join dir, "specifications"
-    end
+    @@dirs ||= Gem::SpecificationRecord.dirs_from(Gem.path)
   end
 
   ##
@@ -918,7 +916,7 @@ def self.dirs
   def self.dirs=(dirs)
     reset
 
-    @@dirs = Array(dirs).map {|dir| File.join dir, "specifications" }
+    @@dirs = Gem::SpecificationRecord.dirs_from(Array(dirs))
   end
 
   extend Enumerable
diff --git a/lib/rubygems/specification_record.rb b/lib/rubygems/specification_record.rb
index bdce0b3a099184..812431fa3297a7 100644
--- a/lib/rubygems/specification_record.rb
+++ b/lib/rubygems/specification_record.rb
@@ -2,6 +2,16 @@
 
 module Gem
   class SpecificationRecord
+    def self.dirs_from(paths)
+      paths.map do |path|
+        File.join(path, "specifications")
+      end
+    end
+
+    def self.from_path(path)
+      new(dirs_from([path]))
+    end
+
     def initialize(dirs)
       @all = nil
       @stubs = nil
diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb
index 7dad521a93b9df..e1f82e6a21bdbb 100644
--- a/lib/rubygems/uninstaller.rb
+++ b/lib/rubygems/uninstaller.rb
@@ -49,7 +49,8 @@ def initialize(gem, options = {})
     # TODO: document the valid options
     @gem                = gem
     @version            = options[:version] || Gem::Requirement.default
-    @gem_home           = File.realpath(options[:install_dir] || Gem.dir)
+    @install_dir        = options[:install_dir]
+    @gem_home           = File.realpath(@install_dir || Gem.dir)
     @force_executables  = options[:executables]
     @force_all          = options[:all]
     @force_ignore       = options[:ignore]
@@ -69,7 +70,7 @@ def initialize(gem, options = {})
 
     # only add user directory if install_dir is not set
     @user_install = false
-    @user_install = options[:user_install] unless options[:install_dir]
+    @user_install = options[:user_install] unless @install_dir
 
     # Optimization: populated during #uninstall
     @default_specs_matching_uninstall_params = []
@@ -290,7 +291,8 @@ def remove_plugins(spec) # :nodoc:
   # Regenerates plugin wrappers after removal.
 
   def regenerate_plugins
-    latest = Gem::Specification.latest_spec_for(@spec.name)
+    specification_record = @install_dir ? Gem::SpecificationRecord.from_path(@install_dir) : Gem::Specification.specification_record
+    latest = specification_record.latest_spec_for(@spec.name)
     return if latest.nil?
 
     regenerate_plugins_for(latest, plugin_dir_for(@spec))
diff --git a/test/rubygems/test_gem_uninstaller.rb b/test/rubygems/test_gem_uninstaller.rb
index 20a0005341475c..eb25b505e6cbd3 100644
--- a/test/rubygems/test_gem_uninstaller.rb
+++ b/test/rubygems/test_gem_uninstaller.rb
@@ -213,6 +213,37 @@ def test_uninstall_with_install_dir_removes_plugins
     Gem::Uninstaller.new(@spec.name, executables: true, install_dir: install_dir).uninstall
 
     assert File.exist?(plugin_path), "plugin unintentionally removed"
+    refute File.exist?(install_dir_plugin_path), "plugin not removed"
+  end
+
+  def test_uninstall_with_install_dir_regenerates_plugins
+    write_file File.join(@tempdir, "lib", "rubygems_plugin.rb") do |io|
+      io.write "# do nothing"
+    end
+
+    @spec.files += %w[lib/rubygems_plugin.rb]
+
+    install_dir = "#{@gemhome}2"
+
+    package = Gem::Package.build(@spec)
+
+    spec_v9 = @spec.dup
+    spec_v9.version = "9"
+    package_v9 = Gem::Package.build(spec_v9)
+
+    Gem::Installer.at(package, force: true, install_dir: install_dir).install
+    Gem::Installer.at(package_v9, force: true, install_dir: install_dir).install
+
+    install_dir_plugin_path = File.join install_dir, "plugins/a_plugin.rb"
+    assert File.exist?(install_dir_plugin_path), "plugin not written"
+
+    Gem::Specification.dirs = [install_dir]
+    Gem::Uninstaller.new(@spec.name, version: "9", executables: true, install_dir: install_dir).uninstall
+    assert File.exist?(install_dir_plugin_path), "plugin unintentionally removed"
+
+    Gem::Specification.dirs = [install_dir]
+    Gem::Uninstaller.new(@spec.name, executables: true, install_dir: install_dir).uninstall
+    refute File.exist?(install_dir_plugin_path), "plugin not removed"
   end
 
   def test_remove_plugins_user_installed

From cb1a574e46f38b9598e98a2648969ac818cf2aa0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 May 2024 02:42:23 +0000
Subject: [PATCH 027/242] Bump github/codeql-action from 3.25.4 to 3.25.5

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 3.25.4 to 3.25.5.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/ccf74c947955fd1cf117aef6a0e4e66191ef6f61...b7cec7526559c32f1616476ff32d17ba4c59b2d6)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/codeql-analysis.yml | 8 ++++----
 .github/workflows/scorecards.yml      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 8191d6beb29852..5fa6da51700ef7 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -80,15 +80,15 @@ jobs:
         run: sudo rm /usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@ccf74c947955fd1cf117aef6a0e4e66191ef6f61 # v3.25.4
+        uses: github/codeql-action/init@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
         with:
           languages: ${{ matrix.language }}
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@ccf74c947955fd1cf117aef6a0e4e66191ef6f61 # v3.25.4
+        uses: github/codeql-action/autobuild@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@ccf74c947955fd1cf117aef6a0e4e66191ef6f61 # v3.25.4
+        uses: github/codeql-action/analyze@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
         with:
           category: '/language:${{ matrix.language }}'
           upload: False
@@ -118,7 +118,7 @@ jobs:
         continue-on-error: true
 
       - name: Upload SARIF
-        uses: github/codeql-action/upload-sarif@ccf74c947955fd1cf117aef6a0e4e66191ef6f61 # v3.25.4
+        uses: github/codeql-action/upload-sarif@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
         with:
           sarif_file: sarif-results/${{ matrix.language }}.sarif
         continue-on-error: true
diff --git a/.github/workflows/scorecards.yml b/.github/workflows/scorecards.yml
index 602902e6a18082..bfc7b958635227 100644
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -67,6 +67,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: 'Upload to code-scanning'
-        uses: github/codeql-action/upload-sarif@ccf74c947955fd1cf117aef6a0e4e66191ef6f61 # v2.1.27
+        uses: github/codeql-action/upload-sarif@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v2.1.27
         with:
           sarif_file: results.sarif

From e33336cb37b47834c0448921c6c4942e3fa63996 Mon Sep 17 00:00:00 2001
From: Samuel Giddins <segiddins@segiddins.me>
Date: Wed, 20 Dec 2023 18:30:06 -0800
Subject: [PATCH 028/242] [ruby/zlib] Avoid allocating intermediary strings
 when read/readpartial are passed an outbuf

This accounts for a significant number of string allocations when reading rubygems, but we can avoid that in many places by only copying into the outbuf when present

https://github.com/ruby/zlib/commit/d25ef406c1
---
 ext/zlib/zlib.c        | 105 ++++++++++++++++++++++++++---------------
 test/zlib/test_zlib.rb |  25 +++++++++-
 2 files changed, 90 insertions(+), 40 deletions(-)

diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c
index fe030725760aea..b1623546e674b0 100644
--- a/ext/zlib/zlib.c
+++ b/ext/zlib/zlib.c
@@ -90,7 +90,7 @@ static void zstream_expand_buffer_into(struct zstream*, unsigned long);
 static int zstream_expand_buffer_non_stream(struct zstream *z);
 static void zstream_append_buffer(struct zstream*, const Bytef*, long);
 static VALUE zstream_detach_buffer(struct zstream*);
-static VALUE zstream_shift_buffer(struct zstream*, long);
+static VALUE zstream_shift_buffer(struct zstream*, long, VALUE);
 static void zstream_buffer_ungets(struct zstream*, const Bytef*, unsigned long);
 static void zstream_buffer_ungetbyte(struct zstream*, int);
 static void zstream_append_input(struct zstream*, const Bytef*, long);
@@ -170,8 +170,8 @@ static void gzfile_check_footer(struct gzfile*, VALUE outbuf);
 static void gzfile_write(struct gzfile*, Bytef*, long);
 static long gzfile_read_more(struct gzfile*, VALUE outbuf);
 static void gzfile_calc_crc(struct gzfile*, VALUE);
-static VALUE gzfile_read(struct gzfile*, long);
-static VALUE gzfile_read_all(struct gzfile*);
+static VALUE gzfile_read(struct gzfile*, long, VALUE);
+static VALUE gzfile_read_all(struct gzfile*, VALUE);
 static void gzfile_ungets(struct gzfile*, const Bytef*, long);
 static void gzfile_ungetbyte(struct gzfile*, int);
 static VALUE gzfile_writer_end_run(VALUE);
@@ -820,19 +820,31 @@ zstream_detach_buffer(struct zstream *z)
 }
 
 static VALUE
-zstream_shift_buffer(struct zstream *z, long len)
+zstream_shift_buffer(struct zstream *z, long len, VALUE dst)
 {
-    VALUE dst;
     char *bufptr;
     long buflen = ZSTREAM_BUF_FILLED(z);
 
     if (buflen <= len) {
-	return zstream_detach_buffer(z);
+        if (NIL_P(dst) || (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&
+                rb_block_given_p())) {
+            return zstream_detach_buffer(z);
+        } else {
+            bufptr = RSTRING_PTR(z->buf);
+            rb_str_resize(dst, buflen);
+            memcpy(RSTRING_PTR(dst), bufptr, buflen);
+        }
+        buflen = 0;
+    } else {
+        bufptr = RSTRING_PTR(z->buf);
+        if (NIL_P(dst)) {
+            dst = rb_str_new(bufptr, len);
+        } else {
+            rb_str_resize(dst, len);
+            memcpy(RSTRING_PTR(dst), bufptr, len);
+        }
+        buflen -= len;
     }
-
-    bufptr = RSTRING_PTR(z->buf);
-    dst = rb_str_new(bufptr, len);
-    buflen -= len;
     memmove(bufptr, bufptr + len, buflen);
     rb_str_set_len(z->buf, buflen);
     z->stream.next_out = (Bytef*)RSTRING_END(z->buf);
@@ -2874,18 +2886,18 @@ gzfile_newstr(struct gzfile *gz, VALUE str)
 }
 
 static long
-gzfile_fill(struct gzfile *gz, long len)
+gzfile_fill(struct gzfile *gz, long len, VALUE outbuf)
 {
     if (len < 0)
         rb_raise(rb_eArgError, "negative length %ld given", len);
     if (len == 0)
 	return 0;
     while (!ZSTREAM_IS_FINISHED(&gz->z) && ZSTREAM_BUF_FILLED(&gz->z) < len) {
-	gzfile_read_more(gz, Qnil);
+	gzfile_read_more(gz, outbuf);
     }
     if (GZFILE_IS_FINISHED(gz)) {
 	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-	    gzfile_check_footer(gz, Qnil);
+	    gzfile_check_footer(gz, outbuf);
 	}
 	return -1;
     }
@@ -2893,14 +2905,27 @@ gzfile_fill(struct gzfile *gz, long len)
 }
 
 static VALUE
-gzfile_read(struct gzfile *gz, long len)
+gzfile_read(struct gzfile *gz, long len, VALUE outbuf)
 {
     VALUE dst;
 
-    len = gzfile_fill(gz, len);
-    if (len == 0) return rb_str_new(0, 0);
-    if (len < 0) return Qnil;
-    dst = zstream_shift_buffer(&gz->z, len);
+    len = gzfile_fill(gz, len, outbuf);
+
+    if (len < 0) {
+        if (!NIL_P(outbuf))
+            rb_str_resize(outbuf, 0);
+        return Qnil;
+    }
+    if (len == 0) {
+        if (NIL_P(outbuf))
+            return rb_str_new(0, 0);
+        else {
+            rb_str_resize(outbuf, 0);
+            return outbuf;
+        }
+    }
+
+    dst = zstream_shift_buffer(&gz->z, len, outbuf);
     if (!NIL_P(dst)) gzfile_calc_crc(gz, dst);
     return dst;
 }
@@ -2933,7 +2958,7 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
 	rb_raise(rb_eEOFError, "end of file reached");
     }
 
-    dst = zstream_shift_buffer(&gz->z, len);
+    dst = zstream_shift_buffer(&gz->z, len, outbuf);
     gzfile_calc_crc(gz, dst);
 
     if (!NIL_P(outbuf)) {
@@ -2945,17 +2970,19 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
 }
 
 static VALUE
-gzfile_read_all(struct gzfile *gz)
+gzfile_read_all(struct gzfile *gz, VALUE dst)
 {
-    VALUE dst;
-
     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
-	gzfile_read_more(gz, Qnil);
+	gzfile_read_more(gz, dst);
     }
     if (GZFILE_IS_FINISHED(gz)) {
 	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-	    gzfile_check_footer(gz, Qnil);
+	    gzfile_check_footer(gz, dst);
 	}
+        if (!NIL_P(dst)) {
+            rb_str_resize(dst, 0);
+            return dst;
+        }
 	return rb_str_new(0, 0);
     }
 
@@ -2993,7 +3020,7 @@ gzfile_getc(struct gzfile *gz)
         de = (unsigned char *)ds + GZFILE_CBUF_CAPA;
         (void)rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
         rb_econv_check_error(gz->ec);
-	dst = zstream_shift_buffer(&gz->z, sp - ss);
+	dst = zstream_shift_buffer(&gz->z, sp - ss, Qnil);
 	gzfile_calc_crc(gz, dst);
 	rb_str_resize(cbuf, dp - ds);
 	return cbuf;
@@ -3001,7 +3028,7 @@ gzfile_getc(struct gzfile *gz)
     else {
 	buf = gz->z.buf;
 	len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
-	dst = gzfile_read(gz, len);
+	dst = gzfile_read(gz, len, Qnil);
 	if (NIL_P(dst)) return dst;
 	return gzfile_newstr(gz, dst);
     }
@@ -3909,7 +3936,7 @@ rb_gzreader_s_zcat(int argc, VALUE *argv, VALUE klass)
             if (!buf) {
                 buf = rb_str_new(0, 0);
             }
-            tmpbuf = gzfile_read_all(get_gzfile(obj));
+            tmpbuf = gzfile_read_all(get_gzfile(obj), Qnil);
             rb_str_cat(buf, RSTRING_PTR(tmpbuf), RSTRING_LEN(tmpbuf));
         }
 
@@ -4011,19 +4038,19 @@ static VALUE
 rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
 {
     struct gzfile *gz = get_gzfile(obj);
-    VALUE vlen;
+    VALUE vlen, outbuf;
     long len;
 
-    rb_scan_args(argc, argv, "01", &vlen);
+    rb_scan_args(argc, argv, "02", &vlen, &outbuf);
     if (NIL_P(vlen)) {
-	return gzfile_read_all(gz);
+	return gzfile_read_all(gz, outbuf);
     }
 
     len = NUM2INT(vlen);
     if (len < 0) {
 	rb_raise(rb_eArgError, "negative length %ld given", len);
     }
-    return gzfile_read(gz, len);
+    return gzfile_read(gz, len, outbuf);
 }
 
 /*
@@ -4096,7 +4123,7 @@ rb_gzreader_getbyte(VALUE obj)
     struct gzfile *gz = get_gzfile(obj);
     VALUE dst;
 
-    dst = gzfile_read(gz, 1);
+    dst = gzfile_read(gz, 1, Qnil);
     if (!NIL_P(dst)) {
 	dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
     }
@@ -4217,7 +4244,7 @@ gzreader_skip_linebreaks(struct gzfile *gz)
 	}
     }
 
-    str = zstream_shift_buffer(&gz->z, n - 1);
+    str = zstream_shift_buffer(&gz->z, n - 1, Qnil);
     gzfile_calc_crc(gz, str);
 }
 
@@ -4238,7 +4265,7 @@ gzreader_charboundary(struct gzfile *gz, long n)
     if (l < n) {
 	int n_bytes = rb_enc_precise_mbclen(p, e, gz->enc);
 	if (MBCLEN_NEEDMORE_P(n_bytes)) {
-	    if ((l = gzfile_fill(gz, n + MBCLEN_NEEDMORE_LEN(n_bytes))) > 0) {
+	    if ((l = gzfile_fill(gz, n + MBCLEN_NEEDMORE_LEN(n_bytes), Qnil)) > 0) {
 		return l;
 	    }
 	}
@@ -4290,10 +4317,10 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
 
     if (NIL_P(rs)) {
 	if (limit < 0) {
-	    dst = gzfile_read_all(gz);
+	    dst = gzfile_read_all(gz, Qnil);
 	    if (RSTRING_LEN(dst) == 0) return Qnil;
 	}
-	else if ((n = gzfile_fill(gz, limit)) <= 0) {
+	else if ((n = gzfile_fill(gz, limit, Qnil)) <= 0) {
 	    return Qnil;
 	}
 	else {
@@ -4303,7 +4330,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
 	    else {
 		n = limit;
 	    }
-	    dst = zstream_shift_buffer(&gz->z, n);
+	    dst = zstream_shift_buffer(&gz->z, n, Qnil);
 	    if (NIL_P(dst)) return dst;
 	    gzfile_calc_crc(gz, dst);
 	    dst = gzfile_newstr(gz, dst);
@@ -4330,7 +4357,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
     while (ZSTREAM_BUF_FILLED(&gz->z) < rslen) {
 	if (ZSTREAM_IS_FINISHED(&gz->z)) {
 	    if (ZSTREAM_BUF_FILLED(&gz->z) > 0) gz->lineno++;
-	    return gzfile_read(gz, rslen);
+	    return gzfile_read(gz, rslen, Qnil);
 	}
 	gzfile_read_more(gz, Qnil);
     }
@@ -4367,7 +4394,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
     }
 
     gz->lineno++;
-    dst = gzfile_read(gz, n);
+    dst = gzfile_read(gz, n, Qnil);
     if (NIL_P(dst)) return dst;
     if (rspara) {
 	gzreader_skip_linebreaks(gz);
diff --git a/test/zlib/test_zlib.rb b/test/zlib/test_zlib.rb
index ae4adc21fe2cf8..15e5bd852fe5d3 100644
--- a/test/zlib/test_zlib.rb
+++ b/test/zlib/test_zlib.rb
@@ -991,6 +991,25 @@ def test_read
           assert_raise(ArgumentError) { f.read(-1) }
           assert_equal(str, f.read)
         end
+
+        Zlib::GzipReader.open(t.path) do |f|
+          s = "".b
+
+          assert_raise(ArgumentError) { f.read(-1, s) }
+
+          assert_same s, f.read(1, s)
+          assert_equal "\xE3".b, s
+
+          assert_same s, f.read(2, s)
+          assert_equal "\x81\x82".b, s
+
+          assert_same s, f.read(6, s)
+          assert_equal "\u3044\u3046".b, s
+
+          assert_nil f.read(1, s)
+          assert_equal "".b, s
+          assert_predicate f, :eof?
+        end
       }
     end
 
@@ -1005,10 +1024,14 @@ def test_readpartial
 
         Zlib::GzipReader.open(t.path) do |f|
           s = "".dup
-          f.readpartial(3, s)
+          assert_same s, f.readpartial(3, s)
           assert("foo".start_with?(s))
 
           assert_raise(ArgumentError) { f.readpartial(-1) }
+
+          assert_same s, f.readpartial(3, s)
+
+          assert_predicate f, :eof?
         end
       }
     end

From e3e1e53098f3214ef12849b3441791465ad7c0a5 Mon Sep 17 00:00:00 2001
From: Samuel Giddins <segiddins@segiddins.me>
Date: Thu, 11 Apr 2024 14:28:07 -0500
Subject: [PATCH 029/242] [ruby/zlib] Avoid double copying into provided outbuf

https://github.com/ruby/zlib/commit/07f44b7546
---
 ext/zlib/zlib.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c
index b1623546e674b0..aad9f8d28a4374 100644
--- a/ext/zlib/zlib.c
+++ b/ext/zlib/zlib.c
@@ -2961,11 +2961,6 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
     dst = zstream_shift_buffer(&gz->z, len, outbuf);
     gzfile_calc_crc(gz, dst);
 
-    if (!NIL_P(outbuf)) {
-        rb_str_resize(outbuf, RSTRING_LEN(dst));
-        memcpy(RSTRING_PTR(outbuf), RSTRING_PTR(dst), RSTRING_LEN(dst));
-	dst = outbuf;
-    }
     return dst;
 }
 

From e73f6618d5d7a36e0599df14d2423544007bdf7c Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Wed, 15 May 2024 16:53:27 +0900
Subject: [PATCH 030/242] [rubygems/rubygems] Do not override `@orig_env`

It is saved in `setup` and restored in `teardown`.

https://github.com/rubygems/rubygems/commit/880c5de667
---
 test/rubygems/helper.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/rubygems/helper.rb b/test/rubygems/helper.rb
index 856dc535882435..7014843bba0fdd 100644
--- a/test/rubygems/helper.rb
+++ b/test/rubygems/helper.rb
@@ -535,12 +535,12 @@ def without_any_upwards_gemfiles
   end
 
   def with_env(overrides, &block)
-    @orig_env = ENV.to_h
+    orig_env = ENV.to_h
     ENV.replace(overrides)
     begin
       block.call
     ensure
-      ENV.replace(@orig_env)
+      ENV.replace(orig_env)
     end
   end
 

From c4a5866798589fb78393b694fcd3359f0ec52b16 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:14:57 -0400
Subject: [PATCH 031/242] [ruby/prism] Replace end of file with end-of-input

https://github.com/ruby/prism/commit/dd532ded95
---
 prism/prism.c                        | 49 +++++++++++++++-------------
 prism/templates/src/token_type.c.erb |  2 +-
 test/prism/errors_test.rb            | 14 ++++----
 3 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 4c8b42f8020e8d..480252cc056d7f 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -13552,8 +13552,8 @@ parse_targets_validate(pm_parser_t *parser, pm_node_t *first_target, pm_binding_
  */
 static pm_statements_node_t *
 parse_statements(pm_parser_t *parser, pm_context_t context) {
-    // First, skip past any optional terminators that might be at the beginning of
-    // the statements.
+    // First, skip past any optional terminators that might be at the beginning
+    // of the statements.
     while (accept2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE));
 
     // If we have a terminator, then we can just return NULL.
@@ -13569,20 +13569,20 @@ parse_statements(pm_parser_t *parser, pm_context_t context) {
         pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_STATEMENT, true, PM_ERR_CANNOT_PARSE_EXPRESSION);
         pm_statements_node_body_append(parser, statements, node);
 
-        // If we're recovering from a syntax error, then we need to stop parsing the
-        // statements now.
+        // If we're recovering from a syntax error, then we need to stop parsing
+        // the statements now.
         if (parser->recovering) {
-            // If this is the level of context where the recovery has happened, then
-            // we can mark the parser as done recovering.
+            // If this is the level of context where the recovery has happened,
+            // then we can mark the parser as done recovering.
             if (context_terminator(context, &parser->current)) parser->recovering = false;
             break;
         }
 
-        // If we have a terminator, then we will parse all consecutive terminators
-        // and then continue parsing the statements list.
+        // If we have a terminator, then we will parse all consecutive
+        // terminators and then continue parsing the statements list.
         if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
-            // If we have a terminator, then we will continue parsing the statements
-            // list.
+            // If we have a terminator, then we will continue parsing the
+            // statements list.
             while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
             if (context_terminator(context, &parser->current)) break;
 
@@ -13590,27 +13590,28 @@ parse_statements(pm_parser_t *parser, pm_context_t context) {
             continue;
         }
 
-        // At this point we have a list of statements that are not terminated by a
-        // newline or semicolon. At this point we need to check if we're at the end
-        // of the statements list. If we are, then we should break out of the loop.
+        // At this point we have a list of statements that are not terminated by
+        // a newline or semicolon. At this point we need to check if we're at
+        // the end of the statements list. If we are, then we should break out
+        // of the loop.
         if (context_terminator(context, &parser->current)) break;
 
         // At this point, we have a syntax error, because the statement was not
         // terminated by a newline or semicolon, and we're not at the end of the
-        // statements list. Ideally we should scan forward to determine if we should
-        // insert a missing terminator or break out of parsing the statements list
-        // at this point.
+        // statements list. Ideally we should scan forward to determine if we
+        // should insert a missing terminator or break out of parsing the
+        // statements list at this point.
         //
-        // We don't have that yet, so instead we'll do a more naive approach. If we
-        // were unable to parse an expression, then we will skip past this token and
-        // continue parsing the statements list. Otherwise we'll add an error and
-        // continue parsing the statements list.
+        // We don't have that yet, so instead we'll do a more naive approach. If
+        // we were unable to parse an expression, then we will skip past this
+        // token and continue parsing the statements list. Otherwise we'll add
+        // an error and continue parsing the statements list.
         if (PM_NODE_TYPE_P(node, PM_MISSING_NODE)) {
             parser_lex(parser);
 
             while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
             if (context_terminator(context, &parser->current)) break;
-        } else if (!accept1(parser, PM_TOKEN_NEWLINE)) {
+        } else if (!accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_EOF)) {
             // This is an inlined version of accept1 because the error that we
             // want to add has varargs. If this happens again, we should
             // probably extract a helper function.
@@ -17428,7 +17429,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
             // If we didn't find a terminator and we didn't find a right
             // parenthesis, then this is a syntax error.
-            if (!terminator_found) {
+            if (!terminator_found && !match1(parser, PM_TOKEN_EOF)) {
                 PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(parser->current.type));
             }
 
@@ -17457,7 +17458,9 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) break;
                 } else if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                     break;
-                } else {
+                } else if (!match1(parser, PM_TOKEN_EOF)) {
+                    // If we're at the end of the file, then we're going to add
+                    // an error after this for the ) anyway.
                     PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(parser->current.type));
                 }
             }
diff --git a/prism/templates/src/token_type.c.erb b/prism/templates/src/token_type.c.erb
index a3095eeab8543f..af6a2ad6fe2a86 100644
--- a/prism/templates/src/token_type.c.erb
+++ b/prism/templates/src/token_type.c.erb
@@ -30,7 +30,7 @@ const char *
 pm_token_type_human(pm_token_type_t token_type) {
     switch (token_type) {
         case PM_TOKEN_EOF:
-            return "end of file";
+            return "end-of-input";
         case PM_TOKEN_MISSING:
             return "missing token";
         case PM_TOKEN_NOT_PROVIDED:
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 5d18780dddb564..c6991519c50a12 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -195,8 +195,7 @@ def test_unterminated_s_symbol
 
     def test_unterminated_parenthesized_expression
       assert_errors expression('(1 + 2'), '(1 + 2', [
-        ["unexpected end of file, expecting end-of-input", 6..6],
-        ["unexpected end of file, assuming it is closing the parent top level context", 6..6],
+        ["unexpected end-of-input, assuming it is closing the parent top level context", 6..6],
         ["expected a matching `)`", 6..6]
       ]
     end
@@ -210,8 +209,8 @@ def test_missing_terminator_in_parentheses
     def test_unterminated_argument_expression
       assert_errors expression('a %'), 'a %', [
         ["invalid `%` token", 2..3],
-        ["unexpected end of file; expected an expression after the operator", 3..3],
-        ["unexpected end of file, assuming it is closing the parent top level context", 3..3]
+        ["unexpected end-of-input; expected an expression after the operator", 3..3],
+        ["unexpected end-of-input, assuming it is closing the parent top level context", 3..3]
       ]
     end
 
@@ -365,7 +364,7 @@ def test_block_beginning_with_brace_and_ending_with_end
       assert_error_messages "x.each { x end", [
         "unexpected 'end', expecting end-of-input",
         "unexpected 'end', ignoring it",
-        "unexpected end of file, assuming it is closing the parent top level context",
+        "unexpected end-of-input, assuming it is closing the parent top level context",
         "expected a block beginning with `{` to end with `}`"
       ]
     end
@@ -1482,8 +1481,7 @@ def test_shadow_args_in_lambda
 
       assert_errors expression(source), source, [
         ["expected a `do` keyword or a `{` to open the lambda block", 3..3],
-        ["unexpected end of file, expecting end-of-input", 7..7],
-        ["unexpected end of file, assuming it is closing the parent top level context", 7..7],
+        ["unexpected end-of-input, assuming it is closing the parent top level context", 7..7],
         ["expected a lambda block beginning with `do` to end with `end`", 7..7]
       ]
     end
@@ -1541,7 +1539,7 @@ def test_while_endless_method
 
       assert_errors expression(source), source, [
         ["expected a predicate expression for the `while` statement", 22..22],
-        ["unexpected end of file, assuming it is closing the parent top level context", 22..22],
+        ["unexpected end-of-input, assuming it is closing the parent top level context", 22..22],
         ["expected an `end` to close the `while` statement", 22..22]
       ]
     end

From cbd1553800c173113f5ea8f1c5d52b00b283d677 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:47:01 -0400
Subject: [PATCH 032/242] [ruby/prism] Extend the bounds of the invalid global
 variable name error

https://github.com/ruby/prism/commit/89d0d9851a
---
 prism/prism.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 480252cc056d7f..97d47c8985f109 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -8995,8 +8995,8 @@ lex_global_variable(pm_parser_t *parser) {
                 // If we get here, then we have a $ followed by something that
                 // isn't recognized as a global variable.
                 pm_diagnostic_id_t diag_id = parser->version == PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_ERR_INVALID_VARIABLE_GLOBAL_3_3 : PM_ERR_INVALID_VARIABLE_GLOBAL;
-                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
-                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, diag_id, (int) ((parser->current.end + width) - parser->current.start), (const char *) parser->current.start);
+                const uint8_t *end = parser->current.end + parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
+                PM_PARSER_ERR_FORMAT(parser, parser->current.start, end, diag_id, (int) (end - parser->current.start), (const char *) parser->current.start);
             }
 
             return PM_TOKEN_GLOBAL_VARIABLE;

From 901f4c3fb77968cd9cb2f1dc2d860cf936a2457d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 12:49:03 -0400
Subject: [PATCH 033/242] [PRISM] Temporarily exclude IRB test

---
 test/.excludes-prism/TestIRB/RubyLexTest.rb | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 test/.excludes-prism/TestIRB/RubyLexTest.rb

diff --git a/test/.excludes-prism/TestIRB/RubyLexTest.rb b/test/.excludes-prism/TestIRB/RubyLexTest.rb
new file mode 100644
index 00000000000000..a2d0a574525d8e
--- /dev/null
+++ b/test/.excludes-prism/TestIRB/RubyLexTest.rb
@@ -0,0 +1 @@
+exclude(:test_code_block_open_with_should_continue, "https://github.com/ruby/irb/pull/956")

From cabc0e093cca984cd6edda0d070b70dc1c125363 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:25:13 -0400
Subject: [PATCH 034/242] [PRISM] Enable
 TestParse#test_unexpected_token_after_numeric

---
 test/.excludes-prism/TestParse.rb | 1 -
 test/ruby/test_parse.rb           | 6 +++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 7cf5f97dd26631..3b390dbedde8bc 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -6,5 +6,4 @@
 exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")
 exclude(:test_unexpected_eof, "error message format")
-exclude(:test_unexpected_token_after_numeric, "error message format")
 exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index bd6dabf2c978d4..1e39fbf72f201e 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -1336,9 +1336,9 @@ def test_unexpected_token_error
   end
 
   def test_unexpected_token_after_numeric
-    assert_syntax_error('0000xyz', /^    \^~~\Z/)
-    assert_syntax_error('1.2i1.1', /^    \^~~\Z/)
-    assert_syntax_error('1.2.3', /^   \^~\Z/)
+    assert_syntax_error('0000xyz', /(^|\| )    \^~~(?!~)/)
+    assert_syntax_error('1.2i1.1', /(^|\| )    \^~~(?!~)/)
+    assert_syntax_error('1.2.3', /(^|\| )   \^~(?!~)/)
     assert_syntax_error('1.', /unexpected end-of-input/)
     assert_syntax_error('1e', /expecting end-of-input/)
   end

From be239cc7bc50d3882bc3dec2bbe1f4f0c1e797fa Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:27:03 -0400
Subject: [PATCH 035/242] [PRISM] Enable TestParse#test_unexpected_eof

---
 test/ruby/test_parse.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index 1e39fbf72f201e..c77cdc56739b04 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -1390,7 +1390,7 @@ def test_eof_in_def
   end
 
   def test_unexpected_eof
-    assert_syntax_error('unless', /^      \^\Z/)
+    assert_syntax_error('unless', /(^|\| )      \^(?!~)/)
   end
 
   def test_location_of_invalid_token

From cd8b28f0e7661498bbae259982809fc7f50e0581 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:40:52 -0400
Subject: [PATCH 036/242] [PRISM] Enable test_location_of_invalid_token

---
 test/.excludes-prism/TestParse.rb | 2 --
 test/ruby/test_parse.rb           | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 3b390dbedde8bc..1c2349cfe51681 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,9 +1,7 @@
 exclude(:test_global_variable, "error message format")
 exclude(:test_invalid_char, "error message format")
-exclude(:test_location_of_invalid_token, "error message format")
 exclude(:test_percent, "error message format")
 exclude(:test_question, "error message format")
 exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")
-exclude(:test_unexpected_eof, "error message format")
 exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index c77cdc56739b04..0035f779570e6d 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -1394,7 +1394,7 @@ def test_unexpected_eof
   end
 
   def test_location_of_invalid_token
-    assert_syntax_error('class xxx end', /^      \^~~\Z/)
+    assert_syntax_error('class xxx end', /(^|\| )      \^~~(?!~)/)
   end
 
   def test_whitespace_warning

From 2aed14d65b6240d03fd9084792855e868e793b2d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 11:48:20 -0400
Subject: [PATCH 037/242] [PRISM] Enable TestParse#test_global_variable

---
 test/.excludes-prism/TestParse.rb | 1 -
 test/ruby/test_parse.rb           | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 1c2349cfe51681..8ff7dba1f4cdcd 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,4 +1,3 @@
-exclude(:test_global_variable, "error message format")
 exclude(:test_invalid_char, "error message format")
 exclude(:test_percent, "error message format")
 exclude(:test_question, "error message format")
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index 0035f779570e6d..63539270fc0793 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -875,7 +875,8 @@ def test_global_variable
     $test_parse_foobarbazqux = nil
     assert_equal(nil, $&)
     assert_equal(nil, eval('alias $& $preserve_last_match'))
-    assert_syntax_error('a = $#', /as a global variable name\na = \$\#\n    \^~$/)
+    assert_syntax_error('a = $#', /as a global variable name/)
+    assert_syntax_error('a = $#', /a = \$\#\n(^|.+?\| )    \^~(?!~)/)
   end
 
   def test_invalid_instance_variable

From 9d69619623ec6b86c464b7cac911b7201f74dab7 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sat, 20 Apr 2024 19:56:58 +0900
Subject: [PATCH 038/242] [rubygems/rubygems] Clean up generated and copied
 files

> leaving the files after gem rebuild was intentional, for local
> inspection, but the test suite should be made to clean up after
> itself independently of that.
https://github.com/rubygems/rubygems/pull/4913#issuecomment-2081710691

https://github.com/rubygems/rubygems/commit/185a2091fb
---
 test/rubygems/test_gem_commands_rebuild_command.rb | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/test/rubygems/test_gem_commands_rebuild_command.rb b/test/rubygems/test_gem_commands_rebuild_command.rb
index 5e8c797e2d11ad..3b7927c44e0308 100644
--- a/test/rubygems/test_gem_commands_rebuild_command.rb
+++ b/test/rubygems/test_gem_commands_rebuild_command.rb
@@ -105,7 +105,7 @@ def util_test_rebuild_gem(gem, args, original_gem_file, gemspec_file, timestamp)
     assert_equal old_spec.name, new_spec.name
     assert_equal old_spec.summary, new_spec.summary
 
-    reproduced
+    [reproduced, original]
   end
 
   def test_build_is_reproducible
@@ -134,12 +134,21 @@ def test_build_is_reproducible
     # also testing that `gem rebuild` overrides the value.
     ENV["SOURCE_DATE_EPOCH"] = Time.new(2007, 8, 9, 10, 11, 12).to_s
 
-    rebuild_gem_file = util_test_rebuild_gem(@gem, [@gem_name, @gem_version], original_gem_file, gemspec_file, timestamp)
+    rebuild_gem_file, saved_gem_file =
+      util_test_rebuild_gem(@gem, [@gem_name, @gem_version], original_gem_file, gemspec_file, timestamp)
 
     rebuild_contents = File.read(rebuild_gem_file)
 
     assert_equal build_contents, rebuild_contents
   ensure
     ENV["SOURCE_DATE_EPOCH"] = epoch
+    if rebuild_gem_file
+      File.unlink(rebuild_gem_file)
+      dir = File.dirname(rebuild_gem_file)
+      Dir.rmdir(dir)
+      File.unlink(saved_gem_file)
+      Dir.rmdir(File.dirname(saved_gem_file))
+      Dir.rmdir(File.dirname(dir))
+    end
   end
 end

From 2dd46bb82ffc4dff01d7ea70922f0e407acafb4e Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 16 May 2024 16:22:17 +0900
Subject: [PATCH 039/242] [Bug #20468] Fix safe navigation in `for` variable

---
 compile.c                | 21 +++++++++++++++------
 test/ruby/test_syntax.rb | 14 ++++++++++++++
 2 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/compile.c b/compile.c
index c319b72b524d78..5167f4d61c3b75 100644
--- a/compile.c
+++ b/compile.c
@@ -5380,12 +5380,17 @@ compile_massign_lhs(rb_iseq_t *iseq, LINK_ANCHOR *const pre, LINK_ANCHOR *const
 
         CHECK(COMPILE_POPPED(pre, "masgn lhs (NODE_ATTRASGN)", node));
 
+        bool safenav_call = false;
         LINK_ELEMENT *insn_element = LAST_ELEMENT(pre);
         iobj = (INSN *)get_prev_insn((INSN *)insn_element); /* send insn */
         ASSUME(iobj);
-        ELEM_REMOVE(LAST_ELEMENT(pre));
-        ELEM_REMOVE((LINK_ELEMENT *)iobj);
-        pre->last = iobj->link.prev;
+        ELEM_REMOVE(insn_element);
+        if (!IS_INSN_ID(iobj, send)) {
+            safenav_call = true;
+            iobj = (INSN *)get_prev_insn(iobj);
+            ELEM_INSERT_NEXT(&iobj->link, insn_element);
+        }
+        (pre->last = iobj->link.prev)->next = 0;
 
         const struct rb_callinfo *ci = (struct rb_callinfo *)OPERAND_AT(iobj, 0);
         int argc = vm_ci_argc(ci) + 1;
@@ -5404,7 +5409,9 @@ compile_massign_lhs(rb_iseq_t *iseq, LINK_ANCHOR *const pre, LINK_ANCHOR *const
             return COMPILE_NG;
         }
 
-        ADD_ELEM(lhs, (LINK_ELEMENT *)iobj);
+        iobj->link.prev = lhs->last;
+        lhs->last->next = &iobj->link;
+        for (lhs->last = &iobj->link; lhs->last->next; lhs->last = lhs->last->next);
         if (vm_ci_flag(ci) & VM_CALL_ARGS_SPLAT) {
             int argc = vm_ci_argc(ci);
             bool dupsplat = false;
@@ -5437,9 +5444,11 @@ compile_massign_lhs(rb_iseq_t *iseq, LINK_ANCHOR *const pre, LINK_ANCHOR *const
             }
             INSERT_BEFORE_INSN1(iobj, line_no, node_id, pushtoarray, INT2FIX(1));
         }
-        ADD_INSN(lhs, line_node, pop);
-        if (argc != 1) {
+        if (!safenav_call) {
             ADD_INSN(lhs, line_node, pop);
+            if (argc != 1) {
+                ADD_INSN(lhs, line_node, pop);
+            }
         }
         for (int i=0; i < argc; i++) {
             ADD_INSN(post, line_node, pop);
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index 7b894eee79ec27..edc3a3cec3fb9d 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -1248,6 +1248,20 @@ def test_safe_call_in_massign_lhs
     assert_syntax_error("a&.x,=0", /multiple assignment destination/)
   end
 
+  def test_safe_call_in_for_variable
+    assert_valid_syntax("for x&.bar in []; end")
+    assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
+    begin;
+      foo = nil
+      for foo&.bar in [1]; end
+      assert_nil(foo)
+
+      foo = Struct.new(:bar).new
+      for foo&.bar in [1]; end
+      assert_equal(1, foo.bar)
+    end;
+  end
+
   def test_no_warning_logop_literal
     assert_warning("") do
       eval("true||raise;nil")

From 4db76d198b4a152c416d657e97959ade3e50a185 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 11:59:55 +0200
Subject: [PATCH 040/242] [rubygems/rubygems] Add a FreeBSD platform helper

https://github.com/rubygems/rubygems/commit/535c83d5be
---
 lib/rubygems.rb | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/rubygems.rb b/lib/rubygems.rb
index ad7ab1075636a8..ac225ca70ae6a6 100644
--- a/lib/rubygems.rb
+++ b/lib/rubygems.rb
@@ -1012,6 +1012,13 @@ def self.solaris_platform?
     RUBY_PLATFORM.include?("solaris")
   end
 
+  ##
+  # Is this platform FreeBSD
+
+  def self.freebsd_platform?
+    RbConfig::CONFIG["host_os"].to_s.include?("bsd")
+  end
+
   ##
   # Load +plugins+ as Ruby files
 

From 9fd41480fbdf7c137b2417851b517aeda33393a0 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 12:04:59 +0200
Subject: [PATCH 041/242] [rubygems/rubygems] Use RubyGems freebsd helper

https://github.com/rubygems/rubygems/commit/5d03a346ab
---
 lib/bundler/cli/install.rb  | 2 +-
 lib/bundler/rubygems_ext.rb | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/bundler/cli/install.rb b/lib/bundler/cli/install.rb
index 6c102d537dfd0f..a233d5d2e5a183 100644
--- a/lib/bundler/cli/install.rb
+++ b/lib/bundler/cli/install.rb
@@ -14,7 +14,7 @@ def run
 
       Bundler.self_manager.install_locked_bundler_and_restart_with_it_if_needed
 
-      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
+      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Gem.freebsd_platform?
 
       # Disable color in deployment mode
       Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
diff --git a/lib/bundler/rubygems_ext.rb b/lib/bundler/rubygems_ext.rb
index 14b870321313c0..18180a81a1c3f9 100644
--- a/lib/bundler/rubygems_ext.rb
+++ b/lib/bundler/rubygems_ext.rb
@@ -23,6 +23,13 @@
 end
 
 module Gem
+  # Can be removed once RubyGems 3.5.11 support is dropped
+  unless Gem.respond_to?(:freebsd_platform?)
+    def self.freebsd_platform?
+      RbConfig::CONFIG["host_os"].to_s.include?("bsd")
+    end
+  end
+
   require "rubygems/specification"
 
   class Specification

From 29a9ab0ba674f3739e453b2c7a68c138c8802b99 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Mon, 13 May 2024 12:05:24 +0200
Subject: [PATCH 042/242] [rubygems/rubygems] Deprecate Bundler constants

https://github.com/rubygems/rubygems/commit/6166e4bce1
---
 lib/bundler/constants.rb | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/bundler/constants.rb b/lib/bundler/constants.rb
index bcbd228b187650..9564771e78afbb 100644
--- a/lib/bundler/constants.rb
+++ b/lib/bundler/constants.rb
@@ -4,6 +4,11 @@
 
 module Bundler
   WINDOWS = RbConfig::CONFIG["host_os"] =~ /(msdos|mswin|djgpp|mingw)/
+  deprecate_constant :WINDOWS
+
   FREEBSD = RbConfig::CONFIG["host_os"].to_s.include?("bsd")
-  NULL    = File::NULL
+  deprecate_constant :FREEBSD
+
+  NULL = File::NULL
+  deprecate_constant :NULL
 end

From 7857061ecd740ef88d8451c5119827e91d57a4fd Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Tue, 14 May 2024 20:07:15 +0200
Subject: [PATCH 043/242] [rubygems/rubygems] Fix regression when caching gems
 from secondary sources

If `cache_all_platforms` setting is enabled, the secondary source was
no longer considering cached gems.

That means that if the remote secondary source has removed its gems,
then this was now resulting in an error while before the previously
cached gem from the source would still be used.

This commit restores previous behavior.

https://github.com/rubygems/rubygems/commit/2d2cd00255
---
 lib/bundler/spec_set.rb             |  1 +
 spec/bundler/commands/cache_spec.rb | 60 +++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/lib/bundler/spec_set.rb b/lib/bundler/spec_set.rb
index 2933d284500668..8e1130e40ed81f 100644
--- a/lib/bundler/spec_set.rb
+++ b/lib/bundler/spec_set.rb
@@ -129,6 +129,7 @@ def materialize(deps)
     def materialized_for_all_platforms
       @specs.map do |s|
         next s unless s.is_a?(LazySpecification)
+        s.source.cached!
         s.source.remote!
         spec = s.materialize_for_installation
         raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
diff --git a/spec/bundler/commands/cache_spec.rb b/spec/bundler/commands/cache_spec.rb
index 70e2c84961d377..37d8b3ac1a47ff 100644
--- a/spec/bundler/commands/cache_spec.rb
+++ b/spec/bundler/commands/cache_spec.rb
@@ -386,6 +386,66 @@
       expect(the_bundle).to include_gems "rack 1.0.0"
     end
 
+    it "uses cached gems for secondary sources when cache_all_platforms configured" do
+      build_repo4 do
+        build_gem "foo", "1.0.0" do |s|
+          s.platform = "x86_64-linux"
+        end
+
+        build_gem "foo", "1.0.0" do |s|
+          s.platform = "arm64-darwin"
+        end
+      end
+
+      gemfile <<~G
+        source "https://gems.repo2"
+
+        source "https://gems.repo4" do
+        gem "foo"
+        end
+      G
+
+      lockfile <<~L
+        GEM
+          remote: https://gems.repo2/
+          specs:
+
+        GEM
+          remote: https://gems.repo4/
+          specs:
+            foo (1.0.0-x86_64-linux)
+            foo (1.0.0-arm64-darwin)
+
+        PLATFORMS
+          arm64-darwin
+          ruby
+          x86_64-linux
+
+        DEPENDENCIES
+          foo
+
+        BUNDLED WITH
+           #{Bundler::VERSION}
+      L
+
+      simulate_platform "x86_64-linux" do
+        bundle "config set cache_all_platforms true"
+        bundle "config set path vendor/bundle"
+        bundle :cache, artifice: "compact_index", env: { "BUNDLER_SPEC_GEM_REPO" => gem_repo4.to_s }
+
+        build_repo4 do
+          # simulate removal of all remote gems
+        end
+
+        # delete compact index cache
+        FileUtils.rm_rf home(".bundle/cache/compact_index")
+
+        bundle "install", artifice: "compact_index", env: { "BUNDLER_SPEC_GEM_REPO" => gem_repo4.to_s }
+
+        expect(the_bundle).to include_gems "foo 1.0.0 x86_64-linux"
+      end
+    end
+
     it "does not reinstall already-installed gems" do
       install_gemfile <<-G
         source "#{file_uri_for(gem_repo1)}"

From 847fc9af1805d8d2277827eb19c0cb4df8509973 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 20:16:32 +0200
Subject: [PATCH 044/242] [rubygems/rubygems] Fix error message calling method
 removed a long time ago

https://github.com/rubygems/rubygems/commit/5fbe5e43d6
---
 lib/rubygems/commands/uninstall_command.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rubygems/commands/uninstall_command.rb b/lib/rubygems/commands/uninstall_command.rb
index 2a77ec72cf1033..283bc96ce3e8cd 100644
--- a/lib/rubygems/commands/uninstall_command.rb
+++ b/lib/rubygems/commands/uninstall_command.rb
@@ -184,7 +184,7 @@ def uninstall_gem(gem_name)
   rescue Gem::GemNotInHomeException => e
     spec = e.spec
     alert("In order to remove #{spec.name}, please execute:\n" \
-          "\tgem uninstall #{spec.name} --install-dir=#{spec.installation_path}")
+          "\tgem uninstall #{spec.name} --install-dir=#{spec.base_dir}")
   rescue Gem::UninstallError => e
     spec = e.spec
     alert_error("Error: unable to successfully uninstall '#{spec.name}' which is " \

From b19693f0ae5077c074ab5a1799cae91e1ef5d7e6 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 20:17:44 +0200
Subject: [PATCH 045/242] [rubygems/rubygems] Improve uninstaller tests

Tests have two copies of b-2 installed, one in default home and another
in user home. But only the one in default home was visible because of
not reloading paths. The user install test was working by chance.

https://github.com/rubygems/rubygems/commit/667537a08f
---
 test/rubygems/test_gem_uninstaller.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/rubygems/test_gem_uninstaller.rb b/test/rubygems/test_gem_uninstaller.rb
index eb25b505e6cbd3..2e4fca011216fb 100644
--- a/test/rubygems/test_gem_uninstaller.rb
+++ b/test/rubygems/test_gem_uninstaller.rb
@@ -429,7 +429,7 @@ def test_uninstall_not_ok
   end
 
   def test_uninstall_user_install
-    @user_spec = Gem::Specification.find_by_name "b"
+    Gem::Specification.dirs = [Gem.user_dir]
 
     uninstaller = Gem::Uninstaller.new(@user_spec.name,
                                        executables: true,

From 5111b3d479c413c3c14df1c4b4dc5d22c9270edb Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 20:51:23 +0200
Subject: [PATCH 046/242] [rubygems/rubygems] Fix `gem uninstall
 --user-install` for symlinked HOME's

https://github.com/rubygems/rubygems/commit/7f0706a897
---
 lib/rubygems/uninstaller.rb           |  5 +++--
 test/rubygems/test_gem_uninstaller.rb | 26 ++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb
index e1f82e6a21bdbb..4d72f6fd0a2cfd 100644
--- a/lib/rubygems/uninstaller.rb
+++ b/lib/rubygems/uninstaller.rb
@@ -51,6 +51,7 @@ def initialize(gem, options = {})
     @version            = options[:version] || Gem::Requirement.default
     @install_dir        = options[:install_dir]
     @gem_home           = File.realpath(@install_dir || Gem.dir)
+    @user_dir           = File.exist?(Gem.user_dir) ? File.realpath(Gem.user_dir) : Gem.user_dir
     @force_executables  = options[:executables]
     @force_all          = options[:all]
     @force_ignore       = options[:ignore]
@@ -105,7 +106,7 @@ def uninstall
 
     list, other_repo_specs = list.partition do |spec|
       @gem_home == spec.base_dir ||
-        (@user_install && spec.base_dir == Gem.user_dir)
+        (@user_install && spec.base_dir == @user_dir)
     end
 
     list.sort!
@@ -239,7 +240,7 @@ def remove_all(list)
 
   def remove(spec)
     unless path_ok?(@gem_home, spec) ||
-           (@user_install && path_ok?(Gem.user_dir, spec))
+           (@user_install && path_ok?(@user_dir, spec))
       e = Gem::GemNotInHomeException.new \
         "Gem '#{spec.full_name}' is not installed in directory #{@gem_home}"
       e.spec = spec
diff --git a/test/rubygems/test_gem_uninstaller.rb b/test/rubygems/test_gem_uninstaller.rb
index 2e4fca011216fb..aa5ab0ed67684d 100644
--- a/test/rubygems/test_gem_uninstaller.rb
+++ b/test/rubygems/test_gem_uninstaller.rb
@@ -453,6 +453,32 @@ def test_uninstall_user_install
     assert_same uninstaller, @post_uninstall_hook_arg
   end
 
+  def test_uninstall_user_install_with_symlinked_home
+    pend "Symlinks not supported or not enabled" unless symlink_supported?
+
+    Gem::Specification.dirs = [Gem.user_dir]
+
+    symlinked_home = File.join(@tempdir, "new-home")
+    FileUtils.ln_s(Gem.user_home, symlinked_home)
+
+    ENV["HOME"] = symlinked_home
+    Gem.instance_variable_set(:@user_home, nil)
+    Gem.instance_variable_set(:@data_home, nil)
+
+    uninstaller = Gem::Uninstaller.new(@user_spec.name,
+                                       executables: true,
+                                       user_install: true,
+                                       force: true)
+
+    gem_dir = File.join @user_spec.gem_dir
+
+    assert_path_exist gem_dir
+
+    uninstaller.uninstall
+
+    assert_path_not_exist gem_dir
+  end
+
   def test_uninstall_wrong_repo
     Dir.mkdir "#{@gemhome}2"
     Gem.use_paths "#{@gemhome}2", [@gemhome]

From d076101af93b28beff15eaa1fcb92ce4f070e9cc Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 16 May 2024 21:25:52 +0900
Subject: [PATCH 047/242] Fix dump of NODE [ci skip]

---
 misc/lldb_rb/utils.py | 451 +++++++++++++++++++++---------------------
 1 file changed, 230 insertions(+), 221 deletions(-)

diff --git a/misc/lldb_rb/utils.py b/misc/lldb_rb/utils.py
index 86b5bdda2d8a13..1b0e4f9f2ab0bb 100644
--- a/misc/lldb_rb/utils.py
+++ b/misc/lldb_rb/utils.py
@@ -60,6 +60,9 @@ def inspect(self, val):
         rbUndef = self.ruby_globals["RUBY_Qundef"]
         rbImmediateMask = self.ruby_globals["RUBY_IMMEDIATE_MASK"]
 
+        if self.inspect_node(val):
+            return
+
         num = val.GetValueAsSigned()
         if num == rbFalse:
             print('false', file=self.result)
@@ -245,227 +248,6 @@ def inspect(self, val):
                     print("T_DATA:", file=self.result)
                     self._append_expression("*(struct RData *) %0#x" % val.GetValueAsUnsigned())
 
-            elif rval.is_type("RUBY_T_NODE"):
-                tRNode = self.target.FindFirstType("struct RNode").GetPointerType()
-                rbNodeTypeMask = self.ruby_globals["RUBY_NODE_TYPEMASK"]
-                rbNodeTypeShift = self.ruby_globals["RUBY_NODE_TYPESHIFT"]
-
-                nd_type = (rval.flags & rbNodeTypeMask) >> rbNodeTypeShift
-                val = val.Cast(tRNode)
-
-                self._append_expression("(node_type) %d" % nd_type)
-
-                if nd_type == self.ruby_globals["NODE_SCOPE"]:
-                    self._append_expression("*(struct RNode_SCOPE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_BLOCK"]:
-                    self._append_expression("*(struct RNode_BLOCK *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_IF"]:
-                    self._append_expression("*(struct RNode_IF *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_UNLESS"]:
-                    self._append_expression("*(struct RNode_UNLESS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CASE"]:
-                    self._append_expression("*(struct RNode_CASE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CASE2"]:
-                    self._append_expression("*(struct RNode_CASE2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CASE3"]:
-                    self._append_expression("*(struct RNode_CASE3 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_WHEN"]:
-                    self._append_expression("*(struct RNode_WHEN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_IN"]:
-                    self._append_expression("*(struct RNode_IN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_WHILE"]:
-                    self._append_expression("*(struct RNode_WHILE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_UNTIL"]:
-                    self._append_expression("*(struct RNode_UNTIL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ITER"]:
-                    self._append_expression("*(struct RNode_ITER *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FOR"]:
-                    self._append_expression("*(struct RNode_FOR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FOR_MASGN"]:
-                    self._append_expression("*(struct RNode_FOR_MASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_BREAK"]:
-                    self._append_expression("*(struct RNode_BREAK *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_NEXT"]:
-                    self._append_expression("*(struct RNode_NEXT *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_REDO"]:
-                    self._append_expression("*(struct RNode_REDO *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_RETRY"]:
-                    self._append_expression("*(struct RNode_RETRY *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_BEGIN"]:
-                    self._append_expression("*(struct RNode_BEGIN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_RESCUE"]:
-                    self._append_expression("*(struct RNode_RESCUE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_RESBODY"]:
-                    self._append_expression("*(struct RNode_RESBODY *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ENSURE"]:
-                    self._append_expression("*(struct RNode_ENSURE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_AND"]:
-                    self._append_expression("*(struct RNode_AND *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OR"]:
-                    self._append_expression("*(struct RNode_OR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_MASGN"]:
-                    self._append_expression("*(struct RNode_MASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_LASGN"]:
-                    self._append_expression("*(struct RNode_LASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DASGN"]:
-                    self._append_expression("*(struct RNode_DASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_GASGN"]:
-                    self._append_expression("*(struct RNode_GASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_IASGN"]:
-                    self._append_expression("*(struct RNode_IASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CDECL"]:
-                    self._append_expression("*(struct RNode_CDECL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CVASGN"]:
-                    self._append_expression("*(struct RNode_CVASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OP_ASGN1"]:
-                    self._append_expression("*(struct RNode_OP_ASGN1 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OP_ASGN2"]:
-                    self._append_expression("*(struct RNode_OP_ASGN2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OP_ASGN_AND"]:
-                    self._append_expression("*(struct RNode_OP_ASGN_AND *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OP_ASGN_OR"]:
-                    self._append_expression("*(struct RNode_OP_ASGN_OR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OP_CDECL"]:
-                    self._append_expression("*(struct RNode_OP_CDECL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CALL"]:
-                    self._append_expression("*(struct RNode_CALL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OPCALL"]:
-                    self._append_expression("*(struct RNode_OPCALL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FCALL"]:
-                    self._append_expression("*(struct RNode_FCALL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_VCALL"]:
-                    self._append_expression("*(struct RNode_VCALL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_QCALL"]:
-                    self._append_expression("*(struct RNode_QCALL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_SUPER"]:
-                    self._append_expression("*(struct RNode_SUPER *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ZSUPER"]:
-                    self._append_expression("*(struct RNode_ZSUPER *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_LIST"]:
-                    self._append_expression("*(struct RNode_LIST *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ZLIST"]:
-                    self._append_expression("*(struct RNode_ZLIST *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_HASH"]:
-                    self._append_expression("*(struct RNode_HASH *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_RETURN"]:
-                    self._append_expression("*(struct RNode_RETURN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_YIELD"]:
-                    self._append_expression("*(struct RNode_YIELD *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_LVAR"]:
-                    self._append_expression("*(struct RNode_LVAR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DVAR"]:
-                    self._append_expression("*(struct RNode_DVAR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_GVAR"]:
-                    self._append_expression("*(struct RNode_GVAR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CONST"]:
-                    self._append_expression("*(struct RNode_CONST *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CVAR"]:
-                    self._append_expression("*(struct RNode_CVAR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_NTH_REF"]:
-                    self._append_expression("*(struct RNode_NTH_REF *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_BACK_REF"]:
-                    self._append_expression("*(struct RNode_BACK_REF *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_MATCH"]:
-                    self._append_expression("*(struct RNode_MATCH *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_MATCH2"]:
-                    self._append_expression("*(struct RNode_MATCH2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_MATCH3"]:
-                    self._append_expression("*(struct RNode_MATCH3 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_STR"]:
-                    self._append_expression("*(struct RNode_STR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DSTR"]:
-                    self._append_expression("*(struct RNode_DSTR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_XSTR"]:
-                    self._append_expression("*(struct RNode_XSTR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DXSTR"]:
-                    self._append_expression("*(struct RNode_DXSTR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_EVSTR"]:
-                    self._append_expression("*(struct RNode_EVSTR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_REGX"]:
-                    self._append_expression("*(struct RNode_REGX *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DREGX"]:
-                    self._append_expression("*(struct RNode_DREGX *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ONCE"]:
-                    self._append_expression("*(struct RNode_ONCE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ARGS"]:
-                    self._append_expression("*(struct RNode_ARGS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ARGS_AUX"]:
-                    self._append_expression("*(struct RNode_ARGS_AUX *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_OPT_ARG"]:
-                    self._append_expression("*(struct RNode_OPT_ARG *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_KW_ARG"]:
-                    self._append_expression("*(struct RNode_KW_ARG *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_POSTARG"]:
-                    self._append_expression("*(struct RNode_POSTARG *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ARGSCAT"]:
-                    self._append_expression("*(struct RNode_ARGSCAT *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ARGSPUSH"]:
-                    self._append_expression("*(struct RNode_ARGSPUSH *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_SPLAT"]:
-                    self._append_expression("*(struct RNode_SPLAT *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DEFN"]:
-                    self._append_expression("*(struct RNode_DEFN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DEFS"]:
-                    self._append_expression("*(struct RNode_DEFS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ALIAS"]:
-                    self._append_expression("*(struct RNode_ALIAS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_VALIAS"]:
-                    self._append_expression("*(struct RNode_VALIAS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_UNDEF"]:
-                    self._append_expression("*(struct RNode_UNDEF *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_CLASS"]:
-                    self._append_expression("*(struct RNode_CLASS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_MODULE"]:
-                    self._append_expression("*(struct RNode_MODULE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_SCLASS"]:
-                    self._append_expression("*(struct RNode_SCLASS *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_COLON2"]:
-                    self._append_expression("*(struct RNode_COLON2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_COLON3"]:
-                    self._append_expression("*(struct RNode_COLON3 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DOT2"]:
-                    self._append_expression("*(struct RNode_DOT2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DOT3"]:
-                    self._append_expression("*(struct RNode_DOT3 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FLIP2"]:
-                    self._append_expression("*(struct RNode_FLIP2 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FLIP3"]:
-                    self._append_expression("*(struct RNode_FLIP3 *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_SELF"]:
-                    self._append_expression("*(struct RNode_SELF *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_NIL"]:
-                    self._append_expression("*(struct RNode_NIL *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_TRUE"]:
-                    self._append_expression("*(struct RNode_TRUE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FALSE"]:
-                    self._append_expression("*(struct RNode_FALSE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ERRINFO"]:
-                    self._append_expression("*(struct RNode_ERRINFO *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DEFINED"]:
-                    self._append_expression("*(struct RNode_DEFINED *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_POSTEXE"]:
-                    self._append_expression("*(struct RNode_POSTEXE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_DSYM"]:
-                    self._append_expression("*(struct RNode_DSYM *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ATTRASGN"]:
-                    self._append_expression("*(struct RNode_ATTRASGN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_LAMBDA"]:
-                    self._append_expression("*(struct RNode_LAMBDA *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ARYPTN"]:
-                    self._append_expression("*(struct RNode_ARYPTN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_HSHPTN"]:
-                    self._append_expression("*(struct RNode_HSHPTN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FNDPTN"]:
-                    self._append_expression("*(struct RNode_FNDPTN *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_ERROR"]:
-                    self._append_expression("*(struct RNode_ERROR *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_LINE"]:
-                    self._append_expression("*(struct RNode_LINE *) %0#x" % val.GetValueAsUnsigned())
-                elif nd_type == self.ruby_globals["NODE_FILE"]:
-                    self._append_expression("*(struct RNode_FILE *) %0#x" % val.GetValueAsUnsigned())
-                else:
-                    self._append_expression("*(struct RNode *) %0#x" % val.GetValueAsUnsigned())
-
             elif rval.is_type("RUBY_T_IMEMO"):
                 imemo_type = ((rval.flags >> self.ruby_globals["RUBY_FL_USHIFT"])
                               & IMEMO_MASK)
@@ -492,3 +274,230 @@ def inspect(self, val):
             else:
                 print("Not-handled type %0#x" % rval.type, file=self.result)
                 print(val, file=self.result)
+
+    def inspect_node(self, val):
+        tRNode = self.target.FindFirstType("struct RNode").GetPointerType()
+
+        # if val.GetType() != tRNode: does not work for unknown reason
+
+        if val.GetType().GetPointeeType().name != "NODE":
+            return False
+
+        rbNodeTypeMask = self.ruby_globals["RUBY_NODE_TYPEMASK"]
+        rbNodeTypeShift = self.ruby_globals["RUBY_NODE_TYPESHIFT"]
+        flags = val.Cast(tRNode).GetChildMemberWithName("flags").GetValueAsUnsigned()
+        nd_type = (flags & rbNodeTypeMask) >> rbNodeTypeShift
+
+        self._append_expression("(node_type) %d" % nd_type)
+
+        if nd_type == self.ruby_globals["NODE_SCOPE"]:
+            self._append_expression("*(struct RNode_SCOPE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_BLOCK"]:
+            self._append_expression("*(struct RNode_BLOCK *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_IF"]:
+            self._append_expression("*(struct RNode_IF *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_UNLESS"]:
+            self._append_expression("*(struct RNode_UNLESS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CASE"]:
+            self._append_expression("*(struct RNode_CASE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CASE2"]:
+            self._append_expression("*(struct RNode_CASE2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CASE3"]:
+            self._append_expression("*(struct RNode_CASE3 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_WHEN"]:
+            self._append_expression("*(struct RNode_WHEN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_IN"]:
+            self._append_expression("*(struct RNode_IN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_WHILE"]:
+            self._append_expression("*(struct RNode_WHILE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_UNTIL"]:
+            self._append_expression("*(struct RNode_UNTIL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ITER"]:
+            self._append_expression("*(struct RNode_ITER *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FOR"]:
+            self._append_expression("*(struct RNode_FOR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FOR_MASGN"]:
+            self._append_expression("*(struct RNode_FOR_MASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_BREAK"]:
+            self._append_expression("*(struct RNode_BREAK *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_NEXT"]:
+            self._append_expression("*(struct RNode_NEXT *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_REDO"]:
+            self._append_expression("*(struct RNode_REDO *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_RETRY"]:
+            self._append_expression("*(struct RNode_RETRY *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_BEGIN"]:
+            self._append_expression("*(struct RNode_BEGIN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_RESCUE"]:
+            self._append_expression("*(struct RNode_RESCUE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_RESBODY"]:
+            self._append_expression("*(struct RNode_RESBODY *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ENSURE"]:
+            self._append_expression("*(struct RNode_ENSURE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_AND"]:
+            self._append_expression("*(struct RNode_AND *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OR"]:
+            self._append_expression("*(struct RNode_OR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_MASGN"]:
+            self._append_expression("*(struct RNode_MASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_LASGN"]:
+            self._append_expression("*(struct RNode_LASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DASGN"]:
+            self._append_expression("*(struct RNode_DASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_GASGN"]:
+            self._append_expression("*(struct RNode_GASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_IASGN"]:
+            self._append_expression("*(struct RNode_IASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CDECL"]:
+            self._append_expression("*(struct RNode_CDECL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CVASGN"]:
+            self._append_expression("*(struct RNode_CVASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OP_ASGN1"]:
+            self._append_expression("*(struct RNode_OP_ASGN1 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OP_ASGN2"]:
+            self._append_expression("*(struct RNode_OP_ASGN2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OP_ASGN_AND"]:
+            self._append_expression("*(struct RNode_OP_ASGN_AND *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OP_ASGN_OR"]:
+            self._append_expression("*(struct RNode_OP_ASGN_OR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OP_CDECL"]:
+            self._append_expression("*(struct RNode_OP_CDECL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CALL"]:
+            self._append_expression("*(struct RNode_CALL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OPCALL"]:
+            self._append_expression("*(struct RNode_OPCALL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FCALL"]:
+            self._append_expression("*(struct RNode_FCALL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_VCALL"]:
+            self._append_expression("*(struct RNode_VCALL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_QCALL"]:
+            self._append_expression("*(struct RNode_QCALL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_SUPER"]:
+            self._append_expression("*(struct RNode_SUPER *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ZSUPER"]:
+            self._append_expression("*(struct RNode_ZSUPER *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_LIST"]:
+            self._append_expression("*(struct RNode_LIST *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ZLIST"]:
+            self._append_expression("*(struct RNode_ZLIST *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_HASH"]:
+            self._append_expression("*(struct RNode_HASH *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_RETURN"]:
+            self._append_expression("*(struct RNode_RETURN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_YIELD"]:
+            self._append_expression("*(struct RNode_YIELD *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_LVAR"]:
+            self._append_expression("*(struct RNode_LVAR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DVAR"]:
+            self._append_expression("*(struct RNode_DVAR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_GVAR"]:
+            self._append_expression("*(struct RNode_GVAR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CONST"]:
+            self._append_expression("*(struct RNode_CONST *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CVAR"]:
+            self._append_expression("*(struct RNode_CVAR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_NTH_REF"]:
+            self._append_expression("*(struct RNode_NTH_REF *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_BACK_REF"]:
+            self._append_expression("*(struct RNode_BACK_REF *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_MATCH"]:
+            self._append_expression("*(struct RNode_MATCH *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_MATCH2"]:
+            self._append_expression("*(struct RNode_MATCH2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_MATCH3"]:
+            self._append_expression("*(struct RNode_MATCH3 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_STR"]:
+            self._append_expression("*(struct RNode_STR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DSTR"]:
+            self._append_expression("*(struct RNode_DSTR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_XSTR"]:
+            self._append_expression("*(struct RNode_XSTR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DXSTR"]:
+            self._append_expression("*(struct RNode_DXSTR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_EVSTR"]:
+            self._append_expression("*(struct RNode_EVSTR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_REGX"]:
+            self._append_expression("*(struct RNode_REGX *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DREGX"]:
+            self._append_expression("*(struct RNode_DREGX *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ONCE"]:
+            self._append_expression("*(struct RNode_ONCE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ARGS"]:
+            self._append_expression("*(struct RNode_ARGS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ARGS_AUX"]:
+            self._append_expression("*(struct RNode_ARGS_AUX *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_OPT_ARG"]:
+            self._append_expression("*(struct RNode_OPT_ARG *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_KW_ARG"]:
+            self._append_expression("*(struct RNode_KW_ARG *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_POSTARG"]:
+            self._append_expression("*(struct RNode_POSTARG *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ARGSCAT"]:
+            self._append_expression("*(struct RNode_ARGSCAT *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ARGSPUSH"]:
+            self._append_expression("*(struct RNode_ARGSPUSH *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_SPLAT"]:
+            self._append_expression("*(struct RNode_SPLAT *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DEFN"]:
+            self._append_expression("*(struct RNode_DEFN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DEFS"]:
+            self._append_expression("*(struct RNode_DEFS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ALIAS"]:
+            self._append_expression("*(struct RNode_ALIAS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_VALIAS"]:
+            self._append_expression("*(struct RNode_VALIAS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_UNDEF"]:
+            self._append_expression("*(struct RNode_UNDEF *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_CLASS"]:
+            self._append_expression("*(struct RNode_CLASS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_MODULE"]:
+            self._append_expression("*(struct RNode_MODULE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_SCLASS"]:
+            self._append_expression("*(struct RNode_SCLASS *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_COLON2"]:
+            self._append_expression("*(struct RNode_COLON2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_COLON3"]:
+            self._append_expression("*(struct RNode_COLON3 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DOT2"]:
+            self._append_expression("*(struct RNode_DOT2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DOT3"]:
+            self._append_expression("*(struct RNode_DOT3 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FLIP2"]:
+            self._append_expression("*(struct RNode_FLIP2 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FLIP3"]:
+            self._append_expression("*(struct RNode_FLIP3 *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_SELF"]:
+            self._append_expression("*(struct RNode_SELF *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_NIL"]:
+            self._append_expression("*(struct RNode_NIL *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_TRUE"]:
+            self._append_expression("*(struct RNode_TRUE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FALSE"]:
+            self._append_expression("*(struct RNode_FALSE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ERRINFO"]:
+            self._append_expression("*(struct RNode_ERRINFO *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DEFINED"]:
+            self._append_expression("*(struct RNode_DEFINED *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_POSTEXE"]:
+            self._append_expression("*(struct RNode_POSTEXE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_DSYM"]:
+            self._append_expression("*(struct RNode_DSYM *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ATTRASGN"]:
+            self._append_expression("*(struct RNode_ATTRASGN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_LAMBDA"]:
+            self._append_expression("*(struct RNode_LAMBDA *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ARYPTN"]:
+            self._append_expression("*(struct RNode_ARYPTN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_HSHPTN"]:
+            self._append_expression("*(struct RNode_HSHPTN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FNDPTN"]:
+            self._append_expression("*(struct RNode_FNDPTN *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_ERROR"]:
+            self._append_expression("*(struct RNode_ERROR *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_LINE"]:
+            self._append_expression("*(struct RNode_LINE *) %0#x" % val.GetValueAsUnsigned())
+        elif nd_type == self.ruby_globals["NODE_FILE"]:
+            self._append_expression("*(struct RNode_FILE *) %0#x" % val.GetValueAsUnsigned())
+        else:
+            self._append_expression("*(struct RNode *) %0#x" % val.GetValueAsUnsigned())
+        return True

From 35c5c7edb9c77398de65cef0636a3cdd2e539bb5 Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 16:00:17 +0200
Subject: [PATCH 048/242] [rubygems/rubygems] Refactor
 `Gem::Specification#find_all_by_name`

So that it can also be delegated to `Gem::SpecificationRecord`.

https://github.com/rubygems/rubygems/commit/1407807a99
---
 lib/rubygems/dependency.rb    | 14 +-------------
 lib/rubygems/specification.rb | 14 ++++++++++++--
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/lib/rubygems/dependency.rb b/lib/rubygems/dependency.rb
index d1bf074441e5e9..5ce9c5e84030a7 100644
--- a/lib/rubygems/dependency.rb
+++ b/lib/rubygems/dependency.rb
@@ -271,15 +271,7 @@ def merge(other)
   end
 
   def matching_specs(platform_only = false)
-    env_req = Gem.env_requirement(name)
-    matches = Gem::Specification.stubs_for(name).find_all do |spec|
-      requirement.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
-    end.map(&:to_spec)
-
-    if prioritizes_bundler?
-      require_relative "bundler_version_finder"
-      Gem::BundlerVersionFinder.prioritize!(matches)
-    end
+    matches = Gem::Specification.find_all_by_name(name, requirement)
 
     if platform_only
       matches.reject! do |spec|
@@ -297,10 +289,6 @@ def specific?
     @requirement.specific?
   end
 
-  def prioritizes_bundler?
-    name == "bundler" && !specific?
-  end
-
   def to_specs
     matches = matching_specs true
 
diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index eb846095293ef7..00ed1cd5810a97 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -937,9 +937,19 @@ def self.each
   # Returns every spec that matches +name+ and optional +requirements+.
 
   def self.find_all_by_name(name, *requirements)
-    requirements = Gem::Requirement.default if requirements.empty?
+    req = Gem::Requirement.create(*requirements)
+    env_req = Gem.env_requirement(name)
+
+    matches = stubs_for(name).find_all do |spec|
+      req.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
+    end.map(&:to_spec)
+
+    if name == "bundler" && !req.specific?
+      require_relative "bundler_version_finder"
+      Gem::BundlerVersionFinder.prioritize!(matches)
+    end
 
-    Gem::Dependency.new(name, *requirements).matching_specs
+    matches
   end
 
   ##

From c55c11d7d5813683dde3eb7791bc2a9d5d39556d Mon Sep 17 00:00:00 2001
From: David Rodriguez <deivid.rodriguez@riseup.net>
Date: Thu, 9 May 2024 17:51:44 +0200
Subject: [PATCH 049/242] [rubygems/rubygems] Fix binstubs sometimes not
 getting regenerated when `--destdir` is given

This was only working for gems also installed in the default gem home.

https://github.com/rubygems/rubygems/commit/47df02dbd9
---
 lib/rubygems/commands/pristine_command.rb     | 15 +++++----
 lib/rubygems/commands/setup_command.rb        |  2 ++
 lib/rubygems/installer.rb                     |  2 +-
 lib/rubygems/specification.rb                 | 22 ++-----------
 lib/rubygems/specification_record.rb          | 32 +++++++++++++++++++
 .../test_gem_commands_setup_command.rb        | 23 +++++++++++--
 6 files changed, 67 insertions(+), 29 deletions(-)

diff --git a/lib/rubygems/commands/pristine_command.rb b/lib/rubygems/commands/pristine_command.rb
index 456d897df23d58..b272a15b6c9dbb 100644
--- a/lib/rubygems/commands/pristine_command.rb
+++ b/lib/rubygems/commands/pristine_command.rb
@@ -57,7 +57,7 @@ def initialize
     end
 
     add_option("-i", "--install-dir DIR",
-               "Gem repository to get binstubs and plugins installed") do |value, options|
+               "Gem repository to get gems restored") do |value, options|
       options[:install_dir] = File.expand_path(value)
     end
 
@@ -103,21 +103,25 @@ def usage # :nodoc:
   end
 
   def execute
+    install_dir = options[:install_dir]
+
+    specification_record = install_dir ? Gem::SpecificationRecord.from_path(install_dir) : Gem::Specification.specification_record
+
     specs = if options[:all]
-      Gem::Specification.map
+      specification_record.map
 
     # `--extensions` must be explicitly given to pristine only gems
     # with extensions.
     elsif options[:extensions_set] &&
           options[:extensions] && options[:args].empty?
-      Gem::Specification.select do |spec|
+      specification_record.select do |spec|
         spec.extensions && !spec.extensions.empty?
       end
     elsif options[:only_missing_extensions]
-      Gem::Specification.select(&:missing_extensions?)
+      specification_record.select(&:missing_extensions?)
     else
       get_all_gem_names.sort.map do |gem_name|
-        Gem::Specification.find_all_by_name(gem_name, options[:version]).reverse
+        specification_record.find_all_by_name(gem_name, options[:version]).reverse
       end.flatten
     end
 
@@ -176,7 +180,6 @@ def execute
         end
 
       bin_dir = options[:bin_dir] if options[:bin_dir]
-      install_dir = options[:install_dir] if options[:install_dir]
 
       installer_options = {
         wrappers: true,
diff --git a/lib/rubygems/commands/setup_command.rb b/lib/rubygems/commands/setup_command.rb
index 3f38074280538e..9c633d6ef73408 100644
--- a/lib/rubygems/commands/setup_command.rb
+++ b/lib/rubygems/commands/setup_command.rb
@@ -585,6 +585,8 @@ def regenerate_binstubs(bindir)
 
     args = %w[--all --only-executables --silent]
     args << "--bindir=#{bindir}"
+    args << "--install-dir=#{default_dir}"
+
     if options[:env_shebang]
       args << "--env-shebang"
     end
diff --git a/lib/rubygems/installer.rb b/lib/rubygems/installer.rb
index 8f6f9a5aa8e894..844f292ba25d3d 100644
--- a/lib/rubygems/installer.rb
+++ b/lib/rubygems/installer.rb
@@ -344,7 +344,7 @@ def install
 
     say spec.post_install_message if options[:post_install_message] && !spec.post_install_message.nil?
 
-    Gem::Specification.add_spec(spec)
+    Gem::Specification.add_spec(spec) unless @install_dir
 
     load_plugin
 
diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb
index 00ed1cd5810a97..57f9b45cf7ab07 100644
--- a/lib/rubygems/specification.rb
+++ b/lib/rubygems/specification.rb
@@ -925,31 +925,15 @@ def self.dirs=(dirs)
   # Enumerate every known spec.  See ::dirs= and ::add_spec to set the list of
   # specs.
 
-  def self.each
-    return enum_for(:each) unless block_given?
-
-    _all.each do |x|
-      yield x
-    end
+  def self.each(&block)
+    specification_record.each(&block)
   end
 
   ##
   # Returns every spec that matches +name+ and optional +requirements+.
 
   def self.find_all_by_name(name, *requirements)
-    req = Gem::Requirement.create(*requirements)
-    env_req = Gem.env_requirement(name)
-
-    matches = stubs_for(name).find_all do |spec|
-      req.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
-    end.map(&:to_spec)
-
-    if name == "bundler" && !req.specific?
-      require_relative "bundler_version_finder"
-      Gem::BundlerVersionFinder.prioritize!(matches)
-    end
-
-    matches
+    specification_record.find_all_by_name(name, *requirements)
   end
 
   ##
diff --git a/lib/rubygems/specification_record.rb b/lib/rubygems/specification_record.rb
index 812431fa3297a7..dd6aa7eafaee3e 100644
--- a/lib/rubygems/specification_record.rb
+++ b/lib/rubygems/specification_record.rb
@@ -111,6 +111,38 @@ def all_names
       all.map(&:full_name)
     end
 
+    include Enumerable
+
+    ##
+    # Enumerate every known spec.
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      all.each do |x|
+        yield x
+      end
+    end
+
+    ##
+    # Returns every spec in the record that matches +name+ and optional +requirements+.
+
+    def find_all_by_name(name, *requirements)
+      req = Gem::Requirement.create(*requirements)
+      env_req = Gem.env_requirement(name)
+
+      matches = stubs_for(name).find_all do |spec|
+        req.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
+      end.map(&:to_spec)
+
+      if name == "bundler" && !req.specific?
+        require_relative "bundler_version_finder"
+        Gem::BundlerVersionFinder.prioritize!(matches)
+      end
+
+      matches
+    end
+
     ##
     # Return the best specification in the record that contains the file matching +path+.
 
diff --git a/test/rubygems/test_gem_commands_setup_command.rb b/test/rubygems/test_gem_commands_setup_command.rb
index 43f695f147a7d3..8eedb6c03aa48d 100644
--- a/test/rubygems/test_gem_commands_setup_command.rb
+++ b/test/rubygems/test_gem_commands_setup_command.rb
@@ -159,6 +159,23 @@ def test_destdir_flag_does_not_try_to_write_to_the_default_gem_home
     end
   end
 
+  def test_destdir_flag_regenerates_binstubs
+    # install to destdir
+    destdir = File.join(@tempdir, "foo")
+    gem_bin_path = gem_install "destdir-only-gem", install_dir: destdir
+
+    # change binstub manually
+    write_file gem_bin_path do |io|
+      io.puts "I changed it!"
+    end
+
+    @cmd.options[:destdir] = destdir
+    @cmd.options[:prefix] = "/"
+    @cmd.execute
+
+    assert_match(/\A#!/, File.read(gem_bin_path))
+  end
+
   def test_files_in
     assert_equal %w[rubygems.rb rubygems/requirement.rb rubygems/ssl_certs/rubygems.org/foo.pem],
                  @cmd.files_in("lib").sort
@@ -412,7 +429,7 @@ def create_dummy_files(list)
     end
   end
 
-  def gem_install(name)
+  def gem_install(name, **options)
     gem = util_spec name do |s|
       s.executables = [name]
       s.files = %W[bin/#{name}]
@@ -420,8 +437,8 @@ def gem_install(name)
     write_file File.join @tempdir, "bin", name do |f|
       f.puts "#!/usr/bin/ruby"
     end
-    install_gem gem
-    File.join @gemhome, "bin", name
+    install_gem gem, **options
+    File.join options[:install_dir] || @gemhome, "bin", name
   end
 
   def gem_install_with_plugin(name)

From 477b13ba17d595cda5c8d38da145ef2600702af5 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 09:41:52 -0400
Subject: [PATCH 050/242] [ruby/prism] Update unterminated string error
 location

https://github.com/ruby/prism/commit/33d12afa60
---
 prism/prism.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/prism/prism.c b/prism/prism.c
index 97d47c8985f109..41075502233727 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -16878,6 +16878,7 @@ parse_strings(pm_parser_t *parser, pm_node_t *current) {
             // start with a single string content node.
             pm_string_t unescaped;
             pm_token_t content;
+
             if (match1(parser, PM_TOKEN_EOF)) {
                 unescaped = PM_STRING_EMPTY;
                 content = not_provided(parser);
@@ -16940,7 +16941,19 @@ parse_strings(pm_parser_t *parser, pm_node_t *current) {
             if (match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                 node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped);
                 pm_node_flag_set(node, parse_unescaped_encoding(parser));
-                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_LITERAL_EOF);
+
+                // Kind of odd behavior, but basically if we have an
+                // unterminated string and it ends in a newline, we back up one
+                // character so that the error message is on the last line of
+                // content in the string.
+                if (!accept1(parser, PM_TOKEN_STRING_END)) {
+                    const uint8_t *location = parser->previous.end;
+                    if (location > parser->start && location[-1] == '\n') location--;
+                    pm_parser_err(parser, location, location, PM_ERR_STRING_LITERAL_EOF);
+
+                    parser->previous.start = parser->previous.end;
+                    parser->previous.type = PM_TOKEN_MISSING;
+                }
             } else if (accept1(parser, PM_TOKEN_LABEL_END)) {
                 node = (pm_node_t *) pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, &content, &unescaped, true));
             } else {

From 011668883ca62bc727f372fa8abb6a64e3a33aae Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 10:01:30 -0400
Subject: [PATCH 051/242] [ruby/prism] Always go to string lex mode even if EOF

https://github.com/ruby/prism/commit/57d5c9be2c
---
 prism/prism.c             | 5 +----
 test/prism/errors_test.rb | 2 +-
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 41075502233727..e6f10f0810aab0 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -11375,10 +11375,7 @@ parser_lex(pm_parser_t *parser) {
 
                             const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                             lex_mode_push_string(parser, true, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
-
-                            if (parser->current.end < parser->end) {
-                                LEX(PM_TOKEN_STRING_BEGIN);
-                            }
+                            LEX(PM_TOKEN_STRING_BEGIN);
                         }
 
                         // Delimiters for %-literals cannot be alphanumeric. We
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index c6991519c50a12..65b913fc3242ef 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -222,7 +222,7 @@ def test_unterminated_interpolated_symbol
 
     def test_cr_without_lf_in_percent_expression
       assert_errors expression("%\r"), "%\r", [
-        ["invalid `%` token", 0..2],
+        ["unterminated string meets end of file", 2..2],
       ]
     end
 

From 7a4b9d1614bfea5277deaab842c30e19a842a827 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 10:23:31 -0400
Subject: [PATCH 052/242] [ruby/prism] Match CRuby error message for unknown %
 string

https://github.com/ruby/prism/commit/863197629c
---
 prism/templates/src/diagnostic.c.erb | 2 +-
 test/prism/errors_test.rb            | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 451f9c3f7cd80c..8e63dd337b65c1 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -235,7 +235,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { "invalid multibyte character 0x%X", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_ESCAPE]           = { "invalid multibyte escape: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_PRINTABLE_CHARACTER]        = { "invalid character `%c`", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_PERCENT]                    = { "invalid `%` token", PM_ERROR_LEVEL_SYNTAX }, // TODO WHAT?
+    [PM_ERR_INVALID_PERCENT]                    = { "unknown type of %string", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ELSE]           = { "Invalid retry after else", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ENSURE]         = { "Invalid retry after ensure", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_WITHOUT_RESCUE]       = { "Invalid retry without rescue", PM_ERROR_LEVEL_SYNTAX },
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 65b913fc3242ef..0cf1c6925bb3fe 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -208,7 +208,7 @@ def test_missing_terminator_in_parentheses
 
     def test_unterminated_argument_expression
       assert_errors expression('a %'), 'a %', [
-        ["invalid `%` token", 2..3],
+        ["unknown type of %string", 2..3],
         ["unexpected end-of-input; expected an expression after the operator", 3..3],
         ["unexpected end-of-input, assuming it is closing the parent top level context", 3..3]
       ]
@@ -1400,7 +1400,7 @@ def test_invalid_number_underscores
     end
 
     def test_alnum_delimiters
-      error_messages = ["invalid `%` token"]
+      error_messages = ["unknown type of %string"]
 
       assert_error_messages "%qXfooX", error_messages
       assert_error_messages "%QXfooX", error_messages

From 910bb4923066b29b42692a82c7310a7fbc36ebb9 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 10:38:16 -0400
Subject: [PATCH 053/242] [ruby/prism] Update error message for invalid % at
 EOF

https://github.com/ruby/prism/commit/178d4f66fd
---
 prism/config.yml                     | 1 +
 prism/prism.c                        | 2 +-
 prism/templates/src/diagnostic.c.erb | 1 +
 test/prism/errors_test.rb            | 2 +-
 4 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/prism/config.yml b/prism/config.yml
index c48e5f28dc7992..0652cc4a9fa2bf 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -153,6 +153,7 @@ errors:
   - INVALID_NUMBER_UNDERSCORE_INNER
   - INVALID_NUMBER_UNDERSCORE_TRAILING
   - INVALID_PERCENT
+  - INVALID_PERCENT_EOF
   - INVALID_PRINTABLE_CHARACTER
   - INVALID_RETRY_AFTER_ELSE
   - INVALID_RETRY_AFTER_ENSURE
diff --git a/prism/prism.c b/prism/prism.c
index e6f10f0810aab0..6befa6bab14590 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -11356,7 +11356,7 @@ parser_lex(pm_parser_t *parser) {
                     // operator because we don't want to move into the string
                     // lex mode unnecessarily.
                     if ((lex_state_beg_p(parser) || lex_state_arg_p(parser)) && (parser->current.end >= parser->end)) {
-                        pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
+                        pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT_EOF);
                         LEX(PM_TOKEN_PERCENT);
                     }
 
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 8e63dd337b65c1..989283fef0892b 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -236,6 +236,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_MULTIBYTE_ESCAPE]           = { "invalid multibyte escape: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_PRINTABLE_CHARACTER]        = { "invalid character `%c`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_PERCENT]                    = { "unknown type of %string", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_PERCENT_EOF]                = { "unterminated quoted string meets end of file", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ELSE]           = { "Invalid retry after else", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_AFTER_ENSURE]         = { "Invalid retry after ensure", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_RETRY_WITHOUT_RESCUE]       = { "Invalid retry without rescue", PM_ERROR_LEVEL_SYNTAX },
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 0cf1c6925bb3fe..1357c97cf97ee5 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -208,7 +208,7 @@ def test_missing_terminator_in_parentheses
 
     def test_unterminated_argument_expression
       assert_errors expression('a %'), 'a %', [
-        ["unknown type of %string", 2..3],
+        ["unterminated quoted string meets end of file", 2..3],
         ["unexpected end-of-input; expected an expression after the operator", 3..3],
         ["unexpected end-of-input, assuming it is closing the parent top level context", 3..3]
       ]

From 0e11781f216c0dbf5f5f3dfbfbb43e14bdfd82ab Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 11:04:01 -0400
Subject: [PATCH 054/242] [ruby/prism] Match CRuby invalid character error
 message

https://github.com/ruby/prism/commit/8d4c5c2bca
---
 prism/templates/src/diagnostic.c.erb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 989283fef0892b..16472bb9cf5b53 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -230,7 +230,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING] = { "trailing '_' in number", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_INVALID_CHARACTER]                  = { "invalid character 0x%X", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_CHARACTER]                  = { "Invalid char '\\x%02X' in expression", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHAR]             = { "invalid multibyte char (%s)", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { "invalid multibyte character 0x%X", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_MULTIBYTE_ESCAPE]           = { "invalid multibyte escape: /%.*s/", PM_ERROR_LEVEL_SYNTAX },

From d314d976d4542f4facbacb8f644014fcbdbcc34d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 11:10:43 -0400
Subject: [PATCH 055/242] [ruby/prism] Match CRuby invalid escape character
 syntax error message

https://github.com/ruby/prism/commit/0ef5658dcc
---
 prism/templates/src/diagnostic.c.erb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 16472bb9cf5b53..eab3dd26bff00c 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -158,10 +158,10 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EMBVAR_INVALID]                     = { "invalid embedded variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_END_UPCASE_BRACE]                   = { "expected a `{` after `END`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_END_UPCASE_TERM]                    = { "expected a `}` to close the `END` statement", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "invalid control escape sequence", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT]      = { "invalid control escape sequence; control cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_HEXADECIMAL]         = { "invalid hex escape sequence", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_META]                = { "invalid meta escape sequence", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_META]                = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_META_REPEAT]         = { "invalid meta escape sequence; meta cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE]             = { "invalid Unicode escape sequence", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { "invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", PM_ERROR_LEVEL_SYNTAX },

From 14debd13210a9a187241a24360bad640e5cd2aa4 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 09:24:38 -0400
Subject: [PATCH 056/242] [PRISM] Enable TestSyntax#test__END___cr

---
 test/.excludes-prism/TestSyntax.rb | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index 0d312618c72836..c65ed92823387e 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,6 +1,4 @@
-exclude(:test__END___cr, "error message format")
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
-exclude(:test_duplicated_when, "error message format")
 exclude(:test_error_message_encoding, "syntax error message encoding")
 exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
 exclude(:test_numbered_parameter, "should raise syntax error for numbered parameters in inner blocks")
@@ -8,5 +6,6 @@
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
 exclude(:test_warn_balanced, "missing warning for ** being interpreted as a binary operator")
 
+exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")
 exclude(:test_keyword_self_reference, "https://bugs.ruby-lang.org/issues/20478")

From 52401a32e5699870d2eef9a492532a0729be204a Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 09:43:09 -0400
Subject: [PATCH 057/242] [PRISM] Enable
 TestSyntax#test_syntax_error_at_newline

---
 test/.excludes-prism/TestSyntax.rb | 1 -
 test/ruby/test_syntax.rb           | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index c65ed92823387e..6e9f51604a370e 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -2,7 +2,6 @@
 exclude(:test_error_message_encoding, "syntax error message encoding")
 exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
 exclude(:test_numbered_parameter, "should raise syntax error for numbered parameters in inner blocks")
-exclude(:test_syntax_error_at_newline, "error message format")
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
 exclude(:test_warn_balanced, "missing warning for ** being interpreted as a binary operator")
 
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index edc3a3cec3fb9d..56b97789e531ac 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -1601,7 +1601,7 @@ def test_syntax_error_in_rescue
   end
 
   def test_syntax_error_at_newline
-    expected = "\n        ^"
+    expected = /(\n|\| )        \^/
     assert_syntax_error("%[abcdef", expected)
     assert_syntax_error("%[abcdef\n", expected)
   end

From 58f993c500ae3f1051fbaa76d21e85bec93fa1f7 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 10:51:04 -0400
Subject: [PATCH 058/242] [PRISM] Enable TestParse#test_percent

---
 test/.excludes-prism/TestParse.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 8ff7dba1f4cdcd..317b09250336c9 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,5 +1,4 @@
 exclude(:test_invalid_char, "error message format")
-exclude(:test_percent, "error message format")
 exclude(:test_question, "error message format")
 exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")

From 7eb45a40fdc8d3e077089b13cef90f2d350509e1 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 11:05:47 -0400
Subject: [PATCH 059/242] [PRISM] Enable TestParse#test_invalid_char

---
 test/.excludes-prism/TestParse.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 317b09250336c9..cf5f1a873547cc 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,4 +1,3 @@
-exclude(:test_invalid_char, "error message format")
 exclude(:test_question, "error message format")
 exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")

From 07241dfac8b64c16c0fc35da55fdb7da8a10dfe4 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 11:11:42 -0400
Subject: [PATCH 060/242] [PRISM] Enable TestParse#test_question

---
 test/.excludes-prism/TestParse.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index cf5f1a873547cc..ba718d063c0800 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,4 +1,3 @@
-exclude(:test_question, "error message format")
 exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")
 exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")

From 286d3032a794500a81bcac9f10363f953d368ef6 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 12:29:14 -0400
Subject: [PATCH 061/242] [ruby/prism] More mixed encoding errors

https://github.com/ruby/prism/commit/2a43b4f55c
---
 prism/prism.c           |  8 ++++++++
 prism/util/pm_strpbrk.c | 38 ++++++++++++++++++++++++++++++++------
 2 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 6befa6bab14590..be6b52f5b1bc26 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -15382,6 +15382,10 @@ parse_string_part(pm_parser_t *parser) {
         //     "aaa #{bbb} #@ccc ddd"
         //          ^^^^^^
         case PM_TOKEN_EMBEXPR_BEGIN: {
+            // Ruby disallows seeing encoding around interpolation in strings,
+            // even though it is known at parse time.
+            parser->explicit_encoding = NULL;
+
             pm_lex_state_t state = parser->lex_state;
             int brace_nesting = parser->brace_nesting;
 
@@ -15414,6 +15418,10 @@ parse_string_part(pm_parser_t *parser) {
         //     "aaa #{bbb} #@ccc ddd"
         //                 ^^^^^
         case PM_TOKEN_EMBVAR: {
+            // Ruby disallows seeing encoding around interpolation in strings,
+            // even though it is known at parse time.
+            parser->explicit_encoding = NULL;
+
             lex_state_set(parser, PM_LEX_STATE_BEG);
             parser_lex(parser);
 
diff --git a/prism/util/pm_strpbrk.c b/prism/util/pm_strpbrk.c
index 6c8dea183679c6..916a4cc3fd3c16 100644
--- a/prism/util/pm_strpbrk.c
+++ b/prism/util/pm_strpbrk.c
@@ -8,6 +8,27 @@ pm_strpbrk_invalid_multibyte_character(pm_parser_t *parser, const uint8_t *start
     pm_diagnostic_list_append_format(&parser->error_list, start, end, PM_ERR_INVALID_MULTIBYTE_CHARACTER, *start);
 }
 
+/**
+ * Set the explicit encoding for the parser to the current encoding.
+ */
+static inline void
+pm_strpbrk_explicit_encoding_set(pm_parser_t *parser, const uint8_t *source, size_t width) {
+    if (parser->explicit_encoding != NULL) {
+        if (parser->explicit_encoding == parser->encoding) {
+            // Okay, we already locked to this encoding.
+        } else if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
+            // Not okay, we already found a Unicode escape sequence and this
+            // conflicts.
+            pm_diagnostic_list_append_format(&parser->error_list, source, source + width, PM_ERR_MIXED_ENCODING, parser->encoding->name);
+        } else {
+            // Should not be anything else.
+            assert(false && "unreachable");
+        }
+    }
+
+    parser->explicit_encoding = parser->encoding;
+}
+
 /**
  * This is the default path.
  */
@@ -52,7 +73,7 @@ pm_strpbrk_utf8(pm_parser_t *parser, const uint8_t *source, const uint8_t *chars
  * This is the path when the encoding is ASCII-8BIT.
  */
 static inline const uint8_t *
-pm_strpbrk_ascii_8bit(const uint8_t *source, const uint8_t *charset, size_t maximum) {
+pm_strpbrk_ascii_8bit(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
     size_t index = 0;
 
     while (index < maximum) {
@@ -60,6 +81,7 @@ pm_strpbrk_ascii_8bit(const uint8_t *source, const uint8_t *charset, size_t maxi
             return source + index;
         }
 
+        if (validate && source[index] >= 0x80) pm_strpbrk_explicit_encoding_set(parser, source, 1);
         index++;
     }
 
@@ -72,6 +94,7 @@ pm_strpbrk_ascii_8bit(const uint8_t *source, const uint8_t *charset, size_t maxi
 static inline const uint8_t *
 pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
     size_t index = 0;
+    const pm_encoding_t *encoding = parser->encoding;
 
     while (index < maximum) {
         if (strchr((const char *) charset, source[index]) != NULL) {
@@ -81,7 +104,8 @@ pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t
         if (source[index] < 0x80) {
             index++;
         } else {
-            size_t width = parser->encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
+            size_t width = encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
+            if (validate) pm_strpbrk_explicit_encoding_set(parser, source, width);
 
             if (width > 0) {
                 index += width;
@@ -96,7 +120,7 @@ pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t
 
                 do {
                     index++;
-                } while (index < maximum && parser->encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);
+                } while (index < maximum && encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);
 
                 pm_strpbrk_invalid_multibyte_character(parser, source + start, source + index);
             }
@@ -113,6 +137,7 @@ pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t
 static inline const uint8_t *
 pm_strpbrk_single_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
     size_t index = 0;
+    const pm_encoding_t *encoding = parser->encoding;
 
     while (index < maximum) {
         if (strchr((const char *) charset, source[index]) != NULL) {
@@ -122,7 +147,8 @@ pm_strpbrk_single_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t
         if (source[index] < 0x80 || !validate) {
             index++;
         } else {
-            size_t width = parser->encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
+            size_t width = encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
+            pm_strpbrk_explicit_encoding_set(parser, source, width);
 
             if (width > 0) {
                 index += width;
@@ -135,7 +161,7 @@ pm_strpbrk_single_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t
 
                 do {
                     index++;
-                } while (index < maximum && parser->encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);
+                } while (index < maximum && encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);
 
                 pm_strpbrk_invalid_multibyte_character(parser, source + start, source + index);
             }
@@ -171,7 +197,7 @@ pm_strpbrk(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, p
     } else if (!parser->encoding_changed) {
         return pm_strpbrk_utf8(parser, source, charset, (size_t) length, validate);
     } else if (parser->encoding == PM_ENCODING_ASCII_8BIT_ENTRY) {
-        return pm_strpbrk_ascii_8bit(source, charset, (size_t) length);
+        return pm_strpbrk_ascii_8bit(parser, source, charset, (size_t) length, validate);
     } else if (parser->encoding->multibyte) {
         return pm_strpbrk_multi_byte(parser, source, charset, (size_t) length, validate);
     } else {

From 0b4cf461e02b84c5ede91ff46b88d844353e1c3d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 13:17:04 -0400
Subject: [PATCH 062/242] [PRISM] Enable TestM17N#test_string_mixed_unicode

---
 test/.excludes-prism/TestM17N.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestM17N.rb b/test/.excludes-prism/TestM17N.rb
index f10c9632d96dda..0367ffa9f2da88 100644
--- a/test/.excludes-prism/TestM17N.rb
+++ b/test/.excludes-prism/TestM17N.rb
@@ -1,2 +1 @@
 exclude(:test_regexp_usascii, "x80 should raise syntax error")
-exclude(:test_string_mixed_unicode, "should raise mixed encoding error")

From 012a80d768affcfb4e747a358f4941647381776b Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 13:28:27 -0400
Subject: [PATCH 063/242] [PRISM] Enable TestISeq#test_syntax_error_message

---
 test/.excludes-prism/TestISeq.rb |  2 --
 test/ruby/test_iseq.rb           | 16 +++++++++++-----
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/test/.excludes-prism/TestISeq.rb b/test/.excludes-prism/TestISeq.rb
index ee3d92494e440e..499ae2e53dbe33 100644
--- a/test/.excludes-prism/TestISeq.rb
+++ b/test/.excludes-prism/TestISeq.rb
@@ -1,4 +1,2 @@
-exclude(:test_syntax_error_message, "error message format")
-
 exclude(:test_each_child, "https://bugs.ruby-lang.org/issues/20479")
 exclude(:test_trace_points, "https://bugs.ruby-lang.org/issues/20479")
diff --git a/test/ruby/test_iseq.rb b/test/ruby/test_iseq.rb
index d2a39e673f3ae6..df4b6651b0216e 100644
--- a/test/ruby/test_iseq.rb
+++ b/test/ruby/test_iseq.rb
@@ -347,11 +347,17 @@ def y@;end
       end
     end
     assert_equal([m1, e1.message], [m2, e2.message], feature11951)
-    message = e1.message.each_line
-    message.with_index(1) do |line, i|
-      next if /^ / =~ line
-      assert_send([line, :start_with?, __FILE__],
-                  proc {message.map {|l, j| (i == j ? ">" : " ") + l}.join("")})
+
+    if e1.message.lines[0] == "#{__FILE__}:#{line}: syntax errors found\n"
+      # Prism lays out the error messages in line with the source, so the
+      # following assertions do not make sense in that context.
+    else
+      message = e1.message.each_line
+      message.with_index(1) do |line, i|
+        next if /^ / =~ line
+        assert_send([line, :start_with?, __FILE__],
+                    proc {message.map {|l, j| (i == j ? ">" : " ") + l}.join("")})
+      end
     end
   end
 

From 98e1e610f6df95aa89481fd92a31a75a808ce2d1 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 14:28:48 -0400
Subject: [PATCH 064/242] [ruby/prism] Update more escape error messages to
 match CRuby

https://github.com/ruby/prism/commit/ab43b3ab66
---
 prism/prism.c                        | 37 +++++++++++++++++++++-------
 prism/templates/src/diagnostic.c.erb |  6 ++---
 test/prism/errors_test.rb            |  5 ++--
 3 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index be6b52f5b1bc26..75f143216122b5 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -9658,7 +9658,8 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                         pm_parser_err(parser, unicode_start, unicode_start + hexadecimal_length, PM_ERR_ESCAPE_INVALID_UNICODE_LONG);
                     } else if (hexadecimal_length == 0) {
                         // there are not hexadecimal characters
-                        pm_parser_err(parser, unicode_start, unicode_start + hexadecimal_length, PM_ERR_ESCAPE_INVALID_UNICODE);
+                        pm_parser_err(parser, parser->current.end, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE);
+                        pm_parser_err(parser, parser->current.end, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_TERM);
                         return;
                     }
 
@@ -9707,10 +9708,6 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                 }
             }
 
-            if (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) {
-                pm_parser_err(parser, start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
-            }
-
             return;
         }
         case 'c': {
@@ -9733,6 +9730,12 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                         return;
                     }
                     parser->current.end++;
+
+                    if (match(parser, 'u') || match(parser, 'U')) {
+                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
+                        return;
+                    }
+
                     escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_CONTROL);
                     return;
                 case ' ':
@@ -9760,7 +9763,8 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
         case 'C': {
             parser->current.end++;
             if (peek(parser) != '-') {
-                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
+                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
+                pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_CONTROL);
                 return;
             }
 
@@ -9783,6 +9787,12 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                         return;
                     }
                     parser->current.end++;
+
+                    if (match(parser, 'u') || match(parser, 'U')) {
+                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
+                        return;
+                    }
+
                     escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_CONTROL);
                     return;
                 case ' ':
@@ -9797,7 +9807,8 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                     return;
                 default: {
                     if (!char_is_ascii_printable(peeked)) {
-                        pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
+                        size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
+                        pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_CONTROL);
                         return;
                     }
 
@@ -9810,7 +9821,8 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
         case 'M': {
             parser->current.end++;
             if (peek(parser) != '-') {
-                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
+                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
+                pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_META);
                 return;
             }
 
@@ -9828,6 +9840,12 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                         return;
                     }
                     parser->current.end++;
+
+                    if (match(parser, 'u') || match(parser, 'U')) {
+                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
+                        return;
+                    }
+
                     escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_META);
                     return;
                 case ' ':
@@ -9842,7 +9860,8 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                     return;
                 default:
                     if (!char_is_ascii_printable(peeked)) {
-                        pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
+                        size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
+                        pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_META);
                         return;
                     }
 
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index eab3dd26bff00c..d9e195e08f3f0e 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -167,7 +167,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { "invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { "invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ESCAPE_INVALID_UNICODE_LONG]        = { "invalid Unicode escape sequence; maximum length is 6 digits", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "invalid Unicode escape sequence; needs closing `}`", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "unterminated Unicode escape", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_ARGUMENT]                    = { "expected an argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EOL_AFTER_STATEMENT]         = { "unexpected %s, expecting end-of-input", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ]   = { "expected an expression after `&&=`", PM_ERROR_LEVEL_SYNTAX },
@@ -330,12 +330,12 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_STATEMENT_PREEXE_BEGIN]             = { "unexpected a `BEGIN` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STATEMENT_UNDEF]                    = { "unexpected an `undef` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_CONCATENATION]               = { "expected a string for concatenation", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_STRING_INTERPOLATED_TERM]           = { "expected a closing delimiter for the interpolated string", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_STRING_INTERPOLATED_TERM]           = { "unterminated string; expected a closing delimiter for the interpolated string", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_LITERAL_EOF]                 = { "unterminated string meets end of file", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_STRING_LITERAL_TERM]                = { "unexpected %s, expected a string literal terminator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_SYMBOL_INVALID]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX }, // TODO expected symbol? prism.c ~9719
     [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { "unterminated quoted string; expected a closing delimiter for the dynamic symbol", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "unterminated symbol; expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_COLON]                      = { "expected a `:` after the true expression of a ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_EXPRESSION_FALSE]           = { "expected an expression after `:` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_TERNARY_EXPRESSION_TRUE]            = { "expected an expression after `?` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 1357c97cf97ee5..3670b90dd76e16 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -216,7 +216,7 @@ def test_unterminated_argument_expression
 
     def test_unterminated_interpolated_symbol
       assert_error_messages ":\"#", [
-        "expected a closing delimiter for the interpolated symbol"
+        "unterminated symbol; expected a closing delimiter for the interpolated symbol"
       ]
     end
 
@@ -715,12 +715,13 @@ def test_do_not_allow_characters_other_than_0_9_a_f_and_A_F_in_u_Unicode_charact
 
       assert_errors expected, '"\u{000z}"', [
         ["invalid Unicode escape sequence", 7..7],
+        ["unterminated Unicode escape", 7..7]
       ]
     end
 
     def test_unterminated_unicode_brackets_should_be_a_syntax_error
       assert_errors expression('?\\u{3'), '?\\u{3', [
-        ["invalid Unicode escape sequence; needs closing `}`", 1..5],
+        ["unterminated Unicode escape", 1..5],
       ]
     end
 

From 92af7054989e6bb605482178f97cee5e59ec9326 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 15:07:03 -0400
Subject: [PATCH 065/242] [ruby/prism] Truncate source lines in errors messages
 when too long

https://github.com/ruby/prism/commit/72518f5716
---
 prism/prism.c                    | 48 +++++++++++++++++++++++++++-----
 test/prism/format_errors_test.rb | 42 +++++++++++++++++++++++++---
 test/prism/newline_test.rb       |  1 +
 3 files changed, 80 insertions(+), 11 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 75f143216122b5..d203b4b7202065 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -21592,6 +21592,7 @@ typedef struct {
 #define PM_COLOR_GRAY "\033[38;5;102m"
 #define PM_COLOR_RED "\033[1;31m"
 #define PM_COLOR_RESET "\033[m"
+#define PM_ERROR_TRUNCATE 30
 
 static inline pm_error_t *
 pm_parser_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
@@ -21646,7 +21647,7 @@ pm_parser_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_l
 }
 
 static inline void
-pm_parser_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t *newline_list, const char *number_prefix, int32_t line, pm_buffer_t *buffer) {
+pm_parser_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t *newline_list, const char *number_prefix, int32_t line, uint32_t column_start, uint32_t column_end, pm_buffer_t *buffer) {
     int32_t line_delta = line - parser->start_line;
     assert(line_delta >= 0);
 
@@ -21663,9 +21664,25 @@ pm_parser_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t
     }
 
     pm_buffer_append_format(buffer, number_prefix, line);
+
+    // Here we determine if we should truncate the end of the line.
+    bool truncate_end = false;
+    if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
+        end = start + column_end + PM_ERROR_TRUNCATE;
+        truncate_end = true;
+    }
+
+    // Here we determine if we should truncate the start of the line.
+    if (column_start >= PM_ERROR_TRUNCATE) {
+        pm_buffer_append_string(buffer, "... ", 4);
+        start += column_start;
+    }
+
     pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
 
-    if (end == parser->end && end[-1] != '\n') {
+    if (truncate_end) {
+        pm_buffer_append_string(buffer, " ...\n", 5);
+    } else if (end == parser->end && end[-1] != '\n') {
         pm_buffer_append_string(buffer, "\n", 1);
     }
 }
@@ -21780,6 +21797,7 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
     // display the same line twice in case the errors are close enough in the
     // source.
     int32_t last_line = parser->start_line - 1;
+    uint32_t last_column_start = 0;
     const pm_encoding_t *encoding = parser->encoding;
 
     for (size_t index = 0; index < error_list->size; index++) {
@@ -21794,11 +21812,11 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
                 }
 
                 pm_buffer_append_string(buffer, "  ", 2);
-                pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, buffer);
+                pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
             }
 
             pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, buffer);
+            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
         }
 
         // If this is the first error or we're on a new line, then we'll display
@@ -21809,7 +21827,17 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
             } else {
                 pm_buffer_append_string(buffer, "> ", 2);
             }
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, buffer);
+
+            last_column_start = error->column_start;
+
+            // Find the maximum column end of all the errors on this line.
+            uint32_t column_end = error->column_end;
+            for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
+                if (errors[next_index].line != error->line) break;
+                if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
+            }
+
+            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
         }
 
         const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
@@ -21828,6 +21856,11 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
         pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
 
         size_t column = 0;
+        if (last_column_start >= PM_ERROR_TRUNCATE) {
+            pm_buffer_append_string(buffer, "    ", 4);
+            column = last_column_start;
+        }
+
         while (column < error->column_start) {
             pm_buffer_append_byte(buffer, ' ');
 
@@ -21867,12 +21900,12 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
 
         if (next_line - last_line > 1) {
             pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, buffer);
+            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
         }
 
         if (next_line - last_line > 1) {
             pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, buffer);
+            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
         }
     }
 
@@ -21880,6 +21913,7 @@ pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list,
     xfree(errors);
 }
 
+#undef PM_ERROR_TRUNCATE
 #undef PM_COLOR_GRAY
 #undef PM_COLOR_RED
 #undef PM_COLOR_RESET
diff --git a/test/prism/format_errors_test.rb b/test/prism/format_errors_test.rb
index a1edbef2e86bd1..63206d5765c775 100644
--- a/test/prism/format_errors_test.rb
+++ b/test/prism/format_errors_test.rb
@@ -6,19 +6,53 @@
 
 module Prism
   class FormatErrorsTest < TestCase
-    def test_format_errors
-      assert_equal <<~ERROR, Debug.format_errors("<>", false)
+    def test_basic
+      expected = <<~ERROR
         > 1 | <>
             | ^ unexpected '<', ignoring it
             |  ^ unexpected '>', ignoring it
       ERROR
 
-      assert_equal <<~'ERROR', Debug.format_errors('"%W"\u"', false)
-        > 1 | "%W"\u"
+      assert_equal expected, Debug.format_errors("<>", false)
+    end
+
+    def test_multiple
+      expected = <<~ERROR
+        > 1 | "%W"\\u"
             |     ^ unexpected backslash, ignoring it
             |      ^ unexpected local variable or method, expecting end-of-input
             |        ^ unterminated string meets end of file
       ERROR
+
+      assert_equal expected, Debug.format_errors('"%W"\u"', false)
+    end
+
+    def test_truncate_start
+      expected = <<~ERROR
+        > 1 | ... <>
+            |     ^ unexpected '<', ignoring it
+            |      ^ unexpected '>', ignoring it
+      ERROR
+
+      assert_equal expected, Debug.format_errors("#{" " * 30}<>", false)
+    end
+
+    def test_truncate_end
+      expected = <<~ERROR
+        > 1 | <#{" " * 30} ...
+            | ^ unexpected '<', ignoring it
+      ERROR
+
+      assert_equal expected, Debug.format_errors("<#{" " * 30}a", false)
+    end
+
+    def test_truncate_both
+      expected = <<~ERROR
+        > 1 | ... <#{" " * 30} ...
+            |     ^ unexpected '<', ignoring it
+      ERROR
+
+      assert_equal expected, Debug.format_errors("#{" " * 30}<#{" " * 30}a", false)
     end
   end
 end
diff --git a/test/prism/newline_test.rb b/test/prism/newline_test.rb
index d31fb89bc6f1c4..f7511f665cdfea 100644
--- a/test/prism/newline_test.rb
+++ b/test/prism/newline_test.rb
@@ -10,6 +10,7 @@ class NewlineTest < TestCase
     filepaths = Dir["*.rb", base: base] - %w[
       encoding_test.rb
       errors_test.rb
+      format_errors_test.rb
       parser_test.rb
       regexp_test.rb
       static_literals_test.rb

From 854cbbd5a9f031c74f9185c2cd8f3dd72784e2d1 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 14:41:11 -0400
Subject: [PATCH 066/242] [PRISM] Enable TestParse#test_string

---
 test/.excludes-prism/TestParse.rb |  1 -
 test/ruby/test_parse.rb           | 54 ++++++++++++++++++-------------
 2 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index ba718d063c0800..513a7ed9429a8f 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,3 +1,2 @@
-exclude(:test_string, "error message format")
 exclude(:test_truncated_source_line, "truncate error message")
 exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")
diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index 63539270fc0793..aa484b5e0b31e7 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -555,34 +555,42 @@ def test_string
     mesg = 'from the backslash through the invalid char'
 
     e = assert_syntax_error('"\xg1"', /hex escape/)
-    assert_equal(' ^~'"\n", e.message.lines.last, mesg)
+    assert_match(/(^|\| ) \^~(?!~)/, e.message.lines.last, mesg)
 
     e = assert_syntax_error('"\u{1234"', 'unterminated Unicode escape')
-    assert_equal('        ^'"\n", e.message.lines.last, mesg)
+    assert_match(/(^|\| )        \^(?!~)/, e.message.lines.last, mesg)
 
     e = assert_syntax_error('"\u{xxxx}"', 'invalid Unicode escape')
-    assert_equal('    ^'"\n", e.message.lines.last, mesg)
+    assert_match(/(^|\| )    \^(?!~)/, e.message.lines.last, mesg)
 
     e = assert_syntax_error('"\u{xxxx', 'Unicode escape')
-    assert_pattern_list([
-                          /.*: invalid Unicode escape\n.*\n/,
-                          /    \^/,
-                          /\n/,
-                          /.*: unterminated Unicode escape\n.*\n/,
-                          /    \^/,
-                          /\n/,
-                          /.*: unterminated string.*\n.*\n/,
-                          /        \^\n/,
-                        ], e.message)
+    if e.message.lines.first == "#{__FILE__}:#{__LINE__ - 1}: syntax errors found\n"
+      assert_pattern_list([
+                            /\s+\| \^ unterminated string;.+\n/,
+                            /\s+\|     \^ unterminated Unicode escape\n/,
+                            /\s+\|     \^ invalid Unicode escape sequence\n/,
+                          ], e.message.lines[2..-1].join)
+    else
+      assert_pattern_list([
+                            /.*: invalid Unicode escape\n.*\n/,
+                            /    \^/,
+                            /\n/,
+                            /.*: unterminated Unicode escape\n.*\n/,
+                            /    \^/,
+                            /\n/,
+                            /.*: unterminated string.*\n.*\n/,
+                            /        \^\n/,
+                          ], e.message)
+    end
 
     e = assert_syntax_error('"\M1"', /escape character syntax/)
-    assert_equal(' ^~~'"\n", e.message.lines.last, mesg)
+    assert_match(/(^|\| ) \^~~(?!~)/, e.message.lines.last, mesg)
 
     e = assert_syntax_error('"\C1"', /escape character syntax/)
-    assert_equal(' ^~~'"\n", e.message.lines.last, mesg)
+    assert_match(/(^|\| ) \^~~(?!~)/, e.message.lines.last, mesg)
 
     src = '"\xD0\u{90'"\n""000000000000000000000000"
-    assert_syntax_error(src, /:#{__LINE__}: unterminated/o)
+    assert_syntax_error(src, /(:#{__LINE__}:|> #{__LINE__} \|.+) unterminated/om)
 
     assert_syntax_error('"\u{100000000}"', /invalid Unicode escape/)
     assert_equal("", eval('"\u{}"'))
@@ -605,22 +613,22 @@ def test_string
     assert_syntax_error("\"\\C-\\M-\x01\"", 'Invalid escape character syntax')
 
     e = assert_syntax_error('"\c\u0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~(?!~)/, e.message.lines.last)
     e = assert_syntax_error('"\c\U0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~(?!~)/, e.message.lines.last)
 
     e = assert_syntax_error('"\C-\u0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~~(?!~)/, e.message.lines.last)
     e = assert_syntax_error('"\C-\U0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~~(?!~)/, e.message.lines.last)
 
     e = assert_syntax_error('"\M-\u0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~~(?!~)/, e.message.lines.last)
     e = assert_syntax_error('"\M-\U0000"', 'Invalid escape character syntax')
-    assert_equal(' ^~~~~'"\n", e.message.lines.last)
+    assert_match(/(^|\| ) \^~~~~(?!~)/, e.message.lines.last)
 
     e = assert_syntax_error(%["\\C-\u3042"], 'Invalid escape character syntax')
-    assert_match(/^\s \^(?# \\ ) ~(?# C ) ~(?# - ) ~+(?# U+3042 )$/x, e.message.lines.last)
+    assert_match(/(^|\|\s)\s \^(?# \\ ) ~(?# C ) ~(?# - ) ~+(?# U+3042 )($|\s)/x, e.message.lines.last)
     assert_not_include(e.message, "invalid multibyte char")
   end
 

From b90ea8ae52d0213900cd5b8b2a47ff6a2a9442df Mon Sep 17 00:00:00 2001
From: Olle Jonsson <olle.jonsson@gmail.com>
Date: Thu, 16 May 2024 07:56:58 +0200
Subject: [PATCH 067/242] [ruby/find] find.gemspec: Drop executables dir config

This gem contains no executables.

https://github.com/ruby/find/commit/7bd452155e
---
 lib/find.gemspec | 2 --
 1 file changed, 2 deletions(-)

diff --git a/lib/find.gemspec b/lib/find.gemspec
index cb845e940985e2..aef24a502844ca 100644
--- a/lib/find.gemspec
+++ b/lib/find.gemspec
@@ -25,7 +25,5 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 end

From 761b90702492cd18f6746b59e77826e0302ca547 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 15:36:04 -0400
Subject: [PATCH 068/242] [PRISM] Enable TestParse#test_truncated_source_line

---
 test/ruby/test_parse.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/ruby/test_parse.rb b/test/ruby/test_parse.rb
index aa484b5e0b31e7..3857f3cc172b2c 100644
--- a/test/ruby/test_parse.rb
+++ b/test/ruby/test_parse.rb
@@ -1353,9 +1353,13 @@ def test_unexpected_token_after_numeric
   end
 
   def test_truncated_source_line
-    e = assert_syntax_error("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 0123456789012345678901234567890123456789",
+    lineno = __LINE__ + 1
+    e = assert_syntax_error("'0123456789012345678901234567890123456789' abcdefghijklmnopqrstuvwxyz0123456789 123456789012345678901234567890123456789",
                             /unexpected local variable or method/)
+
     line = e.message.lines[1]
+    line.delete_prefix!("> #{lineno} | ") if line.start_with?(">")
+
     assert_operator(line, :start_with?, "...")
     assert_operator(line, :end_with?, "...\n")
   end

From 84d2bacb424094f1b57cff0f2dd4381e9f8bd9ed Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 16 May 2024 22:44:52 -0400
Subject: [PATCH 069/242] [ruby/irb] Reorder ruby lex clauses for unrecoverable
 first (https://github.com/ruby/irb/pull/956)

When a syntax error includes multiple error messages, we want to
check for unrecoverable messages first so that we do not
accidentally match a recoverable error later in the message.

https://github.com/ruby/irb/commit/2f42b2360d
---
 lib/irb/ruby-lex.rb | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/lib/irb/ruby-lex.rb b/lib/irb/ruby-lex.rb
index 86e340eb05e568..f6ac7f0f5f51f6 100644
--- a/lib/irb/ruby-lex.rb
+++ b/lib/irb/ruby-lex.rb
@@ -219,27 +219,6 @@ def check_code_syntax(code, local_variables:)
         :unrecoverable_error
       rescue SyntaxError => e
         case e.message
-        when /unterminated (?:string|regexp) meets end of file/
-          # "unterminated regexp meets end of file"
-          #
-          #   example:
-          #     /
-          #
-          # "unterminated string meets end of file"
-          #
-          #   example:
-          #     '
-          return :recoverable_error
-        when /unexpected end-of-input/
-          # "syntax error, unexpected end-of-input, expecting keyword_end"
-          #
-          #   example:
-          #     if true
-          #       hoge
-          #       if false
-          #         fuga
-          #       end
-          return :recoverable_error
         when /unexpected keyword_end/
           # "syntax error, unexpected keyword_end"
           #
@@ -262,6 +241,27 @@ def check_code_syntax(code, local_variables:)
           #   example:
           #     method / f /
           return :unrecoverable_error
+        when /unterminated (?:string|regexp) meets end of file/
+          # "unterminated regexp meets end of file"
+          #
+          #   example:
+          #     /
+          #
+          # "unterminated string meets end of file"
+          #
+          #   example:
+          #     '
+          return :recoverable_error
+        when /unexpected end-of-input/
+          # "syntax error, unexpected end-of-input, expecting keyword_end"
+          #
+          #   example:
+          #     if true
+          #       hoge
+          #       if false
+          #         fuga
+          #       end
+          return :recoverable_error
         else
           return :other_error
         end

From 0f8f0386a8c32812cc5738bdf9c8e74eec34440b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 17 May 2024 02:18:31 +0000
Subject: [PATCH 070/242] Bump actions/checkout from 4.1.5 to 4.1.6

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.5 to 4.1.6.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/44c2b7a8a4ea60a981eaca3cf939b5f4305c123b...a5ac7e51b41094c92402da3b24376905380afc29)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/annocheck.yml          | 2 +-
 .github/workflows/baseruby.yml           | 2 +-
 .github/workflows/bundled_gems.yml       | 2 +-
 .github/workflows/check_dependencies.yml | 2 +-
 .github/workflows/check_misc.yml         | 2 +-
 .github/workflows/codeql-analysis.yml    | 2 +-
 .github/workflows/compilers.yml          | 2 +-
 .github/workflows/macos.yml              | 2 +-
 .github/workflows/mingw.yml              | 2 +-
 .github/workflows/prism.yml              | 2 +-
 .github/workflows/rjit-bindgen.yml       | 2 +-
 .github/workflows/rjit.yml               | 2 +-
 .github/workflows/scorecards.yml         | 2 +-
 .github/workflows/spec_guards.yml        | 2 +-
 .github/workflows/ubuntu.yml             | 2 +-
 .github/workflows/wasm.yml               | 2 +-
 .github/workflows/windows.yml            | 2 +-
 .github/workflows/yjit-macos.yml         | 4 ++--
 .github/workflows/yjit-ubuntu.yml        | 6 +++---
 19 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/.github/workflows/annocheck.yml b/.github/workflows/annocheck.yml
index 0590d8c75e1d7d..6c03f52289199f 100644
--- a/.github/workflows/annocheck.yml
+++ b/.github/workflows/annocheck.yml
@@ -63,7 +63,7 @@ jobs:
       - run: id
         working-directory:
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/baseruby.yml b/.github/workflows/baseruby.yml
index 4876251b82b4fd..ce979c9e7a8c1a 100644
--- a/.github/workflows/baseruby.yml
+++ b/.github/workflows/baseruby.yml
@@ -56,7 +56,7 @@ jobs:
           ruby-version: ${{ matrix.ruby }}
           bundler: none
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       - uses: ./.github/actions/setup/ubuntu
 
diff --git a/.github/workflows/bundled_gems.yml b/.github/workflows/bundled_gems.yml
index c509967c351845..6f06451a99e7c2 100644
--- a/.github/workflows/bundled_gems.yml
+++ b/.github/workflows/bundled_gems.yml
@@ -31,7 +31,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           token: ${{ (github.repository == 'ruby/ruby' && !startsWith(github.event_name, 'pull')) && secrets.MATZBOT_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
 
diff --git a/.github/workflows/check_dependencies.yml b/.github/workflows/check_dependencies.yml
index fbad01a8f47a4d..8ecae4f2236443 100644
--- a/.github/workflows/check_dependencies.yml
+++ b/.github/workflows/check_dependencies.yml
@@ -45,7 +45,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       - uses: ./.github/actions/setup/ubuntu
         if: ${{ contains(matrix.os, 'ubuntu') }}
diff --git a/.github/workflows/check_misc.yml b/.github/workflows/check_misc.yml
index c9a182c57b163d..f26319f4480196 100644
--- a/.github/workflows/check_misc.yml
+++ b/.github/workflows/check_misc.yml
@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           token: ${{ (github.repository == 'ruby/ruby' && !startsWith(github.event_name, 'pull')) && secrets.MATZBOT_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
 
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 5fa6da51700ef7..d6a2e297be3d59 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -63,7 +63,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       - name: Install libraries
         if: ${{ contains(matrix.os, 'macos') }}
diff --git a/.github/workflows/compilers.yml b/.github/workflows/compilers.yml
index d4b047b4e93c85..8937a5b15f28c2 100644
--- a/.github/workflows/compilers.yml
+++ b/.github/workflows/compilers.yml
@@ -233,7 +233,7 @@ jobs:
       - run: id
         working-directory:
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 9d0ff5ae373bf1..e71706b186070d 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -52,7 +52,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/mingw.yml b/.github/workflows/mingw.yml
index f4d399751a6574..4170369def04de 100644
--- a/.github/workflows/mingw.yml
+++ b/.github/workflows/mingw.yml
@@ -97,7 +97,7 @@ jobs:
           $result
         working-directory:
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/prism.yml b/.github/workflows/prism.yml
index 7d4cdcb47ac147..78b6469db19a54 100644
--- a/.github/workflows/prism.yml
+++ b/.github/workflows/prism.yml
@@ -55,7 +55,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/rjit-bindgen.yml b/.github/workflows/rjit-bindgen.yml
index 799be7a847f4df..c4cfe9ed83c0de 100644
--- a/.github/workflows/rjit-bindgen.yml
+++ b/.github/workflows/rjit-bindgen.yml
@@ -51,7 +51,7 @@ jobs:
         with:
           ruby-version: '3.1'
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/rjit.yml b/.github/workflows/rjit.yml
index f1cd70afa4210f..509088db7d54ff 100644
--- a/.github/workflows/rjit.yml
+++ b/.github/workflows/rjit.yml
@@ -55,7 +55,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/scorecards.yml b/.github/workflows/scorecards.yml
index bfc7b958635227..85ee3e2a48c007 100644
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -32,7 +32,7 @@ jobs:
 
     steps:
       - name: 'Checkout code'
-        uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           persist-credentials: false
 
diff --git a/.github/workflows/spec_guards.yml b/.github/workflows/spec_guards.yml
index 2dc4a7b39a6392..14669a13b3c848 100644
--- a/.github/workflows/spec_guards.yml
+++ b/.github/workflows/spec_guards.yml
@@ -45,7 +45,7 @@ jobs:
           - ruby-3.3
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
         with:
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index b808ac5e9e2baa..697056df604751 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -58,7 +58,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/wasm.yml b/.github/workflows/wasm.yml
index 09f8e4bbccdff4..764ca2d21ce8f3 100644
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -61,7 +61,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index d4b9bd644aaf96..fcf600263bb84c 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -123,7 +123,7 @@ jobs:
           Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
         shell: pwsh
 
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/yjit-macos.yml b/.github/workflows/yjit-macos.yml
index c6acd3c614b2d0..bd17b302ae72a1 100644
--- a/.github/workflows/yjit-macos.yml
+++ b/.github/workflows/yjit-macos.yml
@@ -37,7 +37,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       - run: RUST_BACKTRACE=1 cargo test
         working-directory: yjit
@@ -81,7 +81,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github
diff --git a/.github/workflows/yjit-ubuntu.yml b/.github/workflows/yjit-ubuntu.yml
index 2b0c79db28436d..bd7e25a9cd62a2 100644
--- a/.github/workflows/yjit-ubuntu.yml
+++ b/.github/workflows/yjit-ubuntu.yml
@@ -36,7 +36,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       # For now we can't run cargo test --offline because it complains about the
       # capstone dependency, even though the dependency is optional
@@ -68,7 +68,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
       # Check that we don't have linting errors in release mode, too
       - run: cargo clippy --all-targets --all-features
@@ -127,7 +127,7 @@ jobs:
       )}}
 
     steps:
-      - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           sparse-checkout-cone-mode: false
           sparse-checkout: /.github

From 534f1c37e3d7527080921fcc0dd3a42a83ac311d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 17 May 2024 02:24:44 +0000
Subject: [PATCH 071/242] Bump actions/checkout in
 /.github/actions/setup/directories

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.5 to 4.1.6.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/44c2b7a8a4ea60a981eaca3cf939b5f4305c123b...a5ac7e51b41094c92402da3b24376905380afc29)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/actions/setup/directories/action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/actions/setup/directories/action.yml b/.github/actions/setup/directories/action.yml
index db1ae87fffefc5..5264e0e9692b75 100644
--- a/.github/actions/setup/directories/action.yml
+++ b/.github/actions/setup/directories/action.yml
@@ -88,7 +88,7 @@ runs:
         git config --global init.defaultBranch garbage
 
     - if: inputs.checkout
-      uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5
+      uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
       with:
         path: ${{ inputs.srcdir }}
         fetch-depth: ${{ inputs.fetch-depth }}

From 10d02e71d1f57b68f530c0e669e4441fbcdc48ba Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Fri, 17 May 2024 17:17:13 +0900
Subject: [PATCH 072/242] Update bundled_gems

---
 gems/bundled_gems | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gems/bundled_gems b/gems/bundled_gems
index c6bb0f9f545c67..16e16fe5a83830 100644
--- a/gems/bundled_gems
+++ b/gems/bundled_gems
@@ -6,11 +6,11 @@
 # - revision: revision in repository-url to test
 #   if `revision` is not given, "v"+`version` or `version` will be used.
 
-minitest        5.22.3  https://github.com/minitest/minitest ea9caafc0754b1d6236a490d59e624b53209734a
+minitest        5.23.0  https://github.com/minitest/minitest
 power_assert    2.0.3   https://github.com/ruby/power_assert 84e85124c5014a139af39161d484156cfe87a9ed
 rake            13.2.1  https://github.com/ruby/rake
 test-unit       3.6.2   https://github.com/test-unit/test-unit
-rexml           3.2.6   https://github.com/ruby/rexml
+rexml           3.2.8   https://github.com/ruby/rexml
 rss             0.3.0   https://github.com/ruby/rss
 net-ftp         0.3.4   https://github.com/ruby/net-ftp
 net-imap        0.4.11  https://github.com/ruby/net-imap

From 8acec5b6e8a8ed102885da467d47c30657a9a73f Mon Sep 17 00:00:00 2001
From: git <svn-admin@ruby-lang.org>
Date: Fri, 17 May 2024 08:40:30 +0000
Subject: [PATCH 073/242] Update bundled gems list at
 10d02e71d1f57b68f530c0e669e444 [ci skip]

---
 NEWS.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index ce626248a566ad..5972eac924ca40 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -58,9 +58,10 @@ The following default gems are updated.
 
 The following bundled gems are updated.
 
-* minitest 5.22.3
+* minitest 5.23.0
 * rake 13.2.1
 * test-unit 3.6.2
+* rexml 3.2.8
 * net-ftp 0.3.4
 * net-imap 0.4.11
 * net-smtp 0.5.0

From 2d825ca7d0d8d57b49327c3760ec650776ebe60e Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Fri, 17 May 2024 22:02:40 +0900
Subject: [PATCH 074/242] REXML 3.2.8 is not working with rss and
 test-bundled-gems yet.

https://github.com/ruby/ruby/actions/runs/9125437794/job/25091614796#step:11:272
---
 gems/bundled_gems | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gems/bundled_gems b/gems/bundled_gems
index 16e16fe5a83830..bb6dcb5447b992 100644
--- a/gems/bundled_gems
+++ b/gems/bundled_gems
@@ -10,7 +10,7 @@ minitest        5.23.0  https://github.com/minitest/minitest
 power_assert    2.0.3   https://github.com/ruby/power_assert 84e85124c5014a139af39161d484156cfe87a9ed
 rake            13.2.1  https://github.com/ruby/rake
 test-unit       3.6.2   https://github.com/test-unit/test-unit
-rexml           3.2.8   https://github.com/ruby/rexml
+rexml           3.2.6   https://github.com/ruby/rexml
 rss             0.3.0   https://github.com/ruby/rss
 net-ftp         0.3.4   https://github.com/ruby/net-ftp
 net-imap        0.4.11  https://github.com/ruby/net-imap

From 4ba0579da651ef3373fce59034f0fcb8b0ad9e5f Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 17 May 2024 09:45:08 -0400
Subject: [PATCH 075/242] [PRISM] Enable TestSyntax#test_error_message_encoding

---
 prism_compile.c                    | 3 ++-
 test/.excludes-prism/TestSyntax.rb | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/prism_compile.c b/prism_compile.c
index 5ecc69470f9b1c..a53d94f5c2cec3 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -9269,7 +9269,8 @@ pm_parse_process_error(const pm_parse_result_t *result)
         }
     }
 
-    VALUE error = rb_exc_new(rb_eSyntaxError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
+    VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->node.encoding);
+    VALUE error = rb_exc_new_str(rb_eSyntaxError, message);
 
     rb_encoding *filepath_encoding = result->node.filepath_encoding != NULL ? result->node.filepath_encoding : rb_utf8_encoding();
     VALUE path = rb_enc_str_new((const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index 6e9f51604a370e..0505330b1cc399 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,5 +1,4 @@
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
-exclude(:test_error_message_encoding, "syntax error message encoding")
 exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
 exclude(:test_numbered_parameter, "should raise syntax error for numbered parameters in inner blocks")
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")

From aed93ba19ead1186974e1d88ca20a73c5b8b95e7 Mon Sep 17 00:00:00 2001
From: S-H-GAMELINKS <gamelinks007@gmail.com>
Date: Fri, 17 May 2024 11:59:35 +0900
Subject: [PATCH 076/242] [ruby/prism] Replace and Use PM_LOCATION_NULL_VALUE
 macro

https://github.com/ruby/prism/commit/50e188b168
---
 prism/prism.c | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index d203b4b7202065..b22330e1d6d41e 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -1630,7 +1630,7 @@ not_provided(pm_parser_t *parser) {
     return (pm_token_t) { .type = PM_TOKEN_NOT_PROVIDED, .start = parser->start, .end = parser->start };
 }
 
-#define PM_LOCATION_NULL_VALUE(parser) ((pm_location_t) { .start = parser->start, .end = parser->start })
+#define PM_LOCATION_NULL_VALUE(parser) ((pm_location_t) { .start = (parser)->start, .end = (parser)->start })
 #define PM_LOCATION_TOKEN_VALUE(token) ((pm_location_t) { .start = (token)->start, .end = (token)->end })
 #define PM_LOCATION_NODE_VALUE(node) ((pm_location_t) { .start = (node)->location.start, .end = (node)->location.end })
 #define PM_LOCATION_NODE_BASE_VALUE(node) ((pm_location_t) { .start = (node)->base.location.start, .end = (node)->base.location.end })
@@ -2827,8 +2827,7 @@ static pm_call_node_t *
 pm_call_node_fcall_synthesized_create(pm_parser_t *parser, pm_arguments_node_t *arguments, pm_constant_id_t name) {
     pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);
 
-    node->base.location.start = parser->start;
-    node->base.location.end = parser->start;
+    node->base.location = PM_LOCATION_NULL_VALUE(parser);
     node->arguments = arguments;
 
     node->name = name;
@@ -4621,7 +4620,7 @@ pm_global_variable_read_node_synthesized_create(pm_parser_t *parser, pm_constant
     *node = (pm_global_variable_read_node_t) {
         {
             .type = PM_GLOBAL_VARIABLE_READ_NODE,
-            .location = { .start = parser->start, .end = parser->start }
+            .location = PM_LOCATION_NULL_VALUE(parser)
         },
         .name = name
     };
@@ -4663,11 +4662,11 @@ pm_global_variable_write_node_synthesized_create(pm_parser_t *parser, pm_constan
     *node = (pm_global_variable_write_node_t) {
         {
             .type = PM_GLOBAL_VARIABLE_WRITE_NODE,
-            .location = { .start = parser->start, .end = parser->start }
+            .location = PM_LOCATION_NULL_VALUE(parser)
         },
         .name = name,
-        .name_loc = { .start = parser->start, .end = parser->start },
-        .operator_loc = { .start = parser->start, .end = parser->start },
+        .name_loc = PM_LOCATION_NULL_VALUE(parser),
+        .operator_loc = PM_LOCATION_NULL_VALUE(parser),
         .value = value
     };
 
@@ -7355,9 +7354,9 @@ pm_symbol_node_synthesized_create(pm_parser_t *parser, const char *content) {
         {
             .type = PM_SYMBOL_NODE,
             .flags = PM_NODE_FLAG_STATIC_LITERAL | PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING,
-            .location = { .start = parser->start, .end = parser->start }
+            .location = PM_LOCATION_NULL_VALUE(parser)
         },
-        .value_loc = { .start = parser->start, .end = parser->start },
+        .value_loc = PM_LOCATION_NULL_VALUE(parser),
         .unescaped = { 0 }
     };
 
@@ -7483,7 +7482,7 @@ pm_true_node_synthesized_create(pm_parser_t *parser) {
     *node = (pm_true_node_t) {{
         .type = PM_TRUE_NODE,
         .flags = PM_NODE_FLAG_STATIC_LITERAL,
-        .location = { .start = parser->start, .end = parser->end }
+        .location = PM_LOCATION_NULL_VALUE(parser)
     }};
 
     return node;
@@ -7758,10 +7757,10 @@ pm_while_node_synthesized_create(pm_parser_t *parser, pm_node_t *predicate, pm_s
     *node = (pm_while_node_t) {
         {
             .type = PM_WHILE_NODE,
-            .location = { .start = parser->start, .end = parser->start }
+            .location = PM_LOCATION_NULL_VALUE(parser)
         },
-        .keyword_loc = { .start = parser->start, .end = parser->start },
-        .closing_loc = { .start = parser->start, .end = parser->start },
+        .keyword_loc = PM_LOCATION_NULL_VALUE(parser),
+        .closing_loc = PM_LOCATION_NULL_VALUE(parser),
         .predicate = predicate,
         .statements = statements
     };

From 0649c1e3bc6d20034aac352046953a3a275d3745 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 17 May 2024 10:47:13 -0400
Subject: [PATCH 077/242] [ruby/prism] Revert incorrect synthesized true node
 change

https://github.com/ruby/prism/commit/31ef81fd06
---
 prism/prism.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prism/prism.c b/prism/prism.c
index b22330e1d6d41e..02c208808988e9 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -7482,7 +7482,7 @@ pm_true_node_synthesized_create(pm_parser_t *parser) {
     *node = (pm_true_node_t) {{
         .type = PM_TRUE_NODE,
         .flags = PM_NODE_FLAG_STATIC_LITERAL,
-        .location = PM_LOCATION_NULL_VALUE(parser)
+        .location = { .start = parser->start, .end = parser->end }
     }};
 
     return node;

From c60cdbdc9818a8aee091dc4c07aeb78096828ffc Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 17 May 2024 10:35:30 -0400
Subject: [PATCH 078/242] [PRISM] Emit END event for modules

---
 prism_compile.c  | 2 +-
 spec/prism.mspec | 4 ----
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/prism_compile.c b/prism_compile.c
index a53d94f5c2cec3..9207f7a5f556bd 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -8745,7 +8745,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             break;
         }
 
-        if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE)) {
+        if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
             const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, scope_node->ast_node);
             ADD_TRACE(ret, RUBY_EVENT_END);
             ISEQ_COMPILE_DATA(iseq)->last_line = end_location.line;
diff --git a/spec/prism.mspec b/spec/prism.mspec
index 3014b9788feac1..42956c6e7bc353 100644
--- a/spec/prism.mspec
+++ b/spec/prism.mspec
@@ -1,8 +1,4 @@
 # frozen_string_literal: true
 
-# We are missing emitting some :end event inside eval; we need more
-# investigation here.
-MSpec.register(:exclude, "TracePoint#path equals \"(eval at __FILE__:__LINE__)\" inside an eval for :end event")
-
 # We need to respect the eval coverage setting.
 MSpec.register(:exclude, "Coverage.result returns the correct results when eval coverage is disabled")

From e61d24d77e53a4114da64948c072380c7270d309 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 17 May 2024 10:43:31 -0400
Subject: [PATCH 079/242] [PRISM] Enable passing IRB test

---
 test/.excludes-prism/TestIRB/RubyLexTest.rb | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 test/.excludes-prism/TestIRB/RubyLexTest.rb

diff --git a/test/.excludes-prism/TestIRB/RubyLexTest.rb b/test/.excludes-prism/TestIRB/RubyLexTest.rb
deleted file mode 100644
index a2d0a574525d8e..00000000000000
--- a/test/.excludes-prism/TestIRB/RubyLexTest.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_code_block_open_with_should_continue, "https://github.com/ruby/irb/pull/956")

From cce7c25a42cbe46b9daea7c1e0accda00fe91c43 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 17 May 2024 11:33:08 -0400
Subject: [PATCH 080/242] [PRISM] Enable TestRequire

---
 prism_compile.c                     | 1 +
 test/.excludes-prism/TestRequire.rb | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 test/.excludes-prism/TestRequire.rb

diff --git a/prism_compile.c b/prism_compile.c
index 9207f7a5f556bd..44ac70d2fa276c 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -9454,6 +9454,7 @@ pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error)
 VALUE
 pm_parse_file(pm_parse_result_t *result, VALUE filepath)
 {
+    result->node.filepath_encoding = rb_enc_get(filepath);
     pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
     RB_GC_GUARD(filepath);
 
diff --git a/test/.excludes-prism/TestRequire.rb b/test/.excludes-prism/TestRequire.rb
deleted file mode 100644
index cb35d59c6008be..00000000000000
--- a/test/.excludes-prism/TestRequire.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_require_nonascii_path_shift_jis, "requiring non-ascii paths")

From 55c62e676f3b30b47978684ab871e9d6e906fc27 Mon Sep 17 00:00:00 2001
From: yui-knk <spiketeika@gmail.com>
Date: Wed, 15 May 2024 09:32:36 +0900
Subject: [PATCH 081/242] No need to specify tags anymore

In the past, these codes were used by both parser and ripper.
On ripper, the type of LHS is `<val>` then type cast was needed.
However currently these are only used by parser then no need to
cast.
---
 parse.y | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/parse.y b/parse.y
index 5fe9babefaea05..6365f4c89ba6c0 100644
--- a/parse.y
+++ b/parse.y
@@ -3613,14 +3613,14 @@ command		: fcall command_args       %prec tLOWEST
                     {
                         NODE *args = 0;
                         args = ret_args(p, $2);
-                        $<node>$ = add_block_exit(p, NEW_BREAK(args, &@$));
+                        $$ = add_block_exit(p, NEW_BREAK(args, &@$));
                     /*% ripper: break!($:2) %*/
                     }
                 | keyword_next call_args
                     {
                         NODE *args = 0;
                         args = ret_args(p, $2);
-                        $<node>$ = add_block_exit(p, NEW_NEXT(args, &@$));
+                        $$ = add_block_exit(p, NEW_NEXT(args, &@$));
                     /*% ripper: next!($:2) %*/
                     }
                 ;
@@ -4790,17 +4790,17 @@ primary		: literal
                     }
                 | keyword_break
                     {
-                        $<node>$ = add_block_exit(p, NEW_BREAK(0, &@$));
+                        $$ = add_block_exit(p, NEW_BREAK(0, &@$));
                     /*% ripper: break!(args_new!) %*/
                     }
                 | keyword_next
                     {
-                        $<node>$ = add_block_exit(p, NEW_NEXT(0, &@$));
+                        $$ = add_block_exit(p, NEW_NEXT(0, &@$));
                     /*% ripper: next!(args_new!) %*/
                     }
                 | keyword_redo
                     {
-                        $<node>$ = add_block_exit(p, NEW_REDO(&@$));
+                        $$ = add_block_exit(p, NEW_REDO(&@$));
                     /*% ripper: redo! %*/
                     }
                 | keyword_retry

From ac85eef18ba0f5afa088c6a463f2ed8163692766 Mon Sep 17 00:00:00 2001
From: BurdetteLamar <burdettelamar@yahoo.com>
Date: Fri, 17 May 2024 23:15:42 +0100
Subject: [PATCH 082/242] Fix links

---
 complex.c | 4 ++--
 string.rb | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/complex.c b/complex.c
index ff278f80fae3a6..f562ed316123c7 100644
--- a/complex.c
+++ b/complex.c
@@ -2470,7 +2470,7 @@ float_arg(VALUE self)
  *
  * The rectangular coordinates of a complex number
  * are called the _real_ and _imaginary_ parts;
- * see {Complex number definition}[https://en.wikipedia.org/wiki/Complex_number#Definition].
+ * see {Complex number definition}[https://en.wikipedia.org/wiki/Complex_number#Definition_and_basic_operations].
  *
  * You can create a \Complex object from rectangular coordinates with:
  *
@@ -2495,7 +2495,7 @@ float_arg(VALUE self)
  *
  * The polar coordinates of a complex number
  * are called the _absolute_ and _argument_ parts;
- * see {Complex polar plane}[https://en.wikipedia.org/wiki/Complex_number#Polar_complex_plane].
+ * see {Complex polar plane}[https://en.wikipedia.org/wiki/Complex_number#Polar_form].
  *
  * In this class, the argument part
  * in expressed {radians}[https://en.wikipedia.org/wiki/Radian]
diff --git a/string.rb b/string.rb
index 00d76cbe03f0b3..bec4e8cecfbf2c 100644
--- a/string.rb
+++ b/string.rb
@@ -311,7 +311,7 @@
 #  - {Comparing}[rdoc-ref:String@Methods+for+Comparing]
 #  - {Modifying a String}[rdoc-ref:String@Methods+for+Modifying+a+String]
 #  - {Converting to New String}[rdoc-ref:String@Methods+for+Converting+to+New+String]
-#  - {Converting to Non-String}[rdoc-ref:String@Methods+for+Converting+to+Non--5CString]
+#  - {Converting to Non-String}[rdoc-ref:String@Methods+for+Converting+to+Non-String]
 #  - {Iterating}[rdoc-ref:String@Methods+for+Iterating]
 #
 #  === Methods for Creating a +String+

From 232f7b37cf1e13d0fff6c8ffc8a342f1c126cd98 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sat, 18 May 2024 19:46:05 +0900
Subject: [PATCH 083/242] Replace cast tags with typed midrule actions

* Add types to `tLAMBDA` and `tSTRING_DBEG` to store corresponding
  information when returning these tokens.
* Add `enum lex_state_e state` to `%union` for `tSTRING_DBEG`.
---
 parse.y | 64 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/parse.y b/parse.y
index 6365f4c89ba6c0..de52170cb4e041 100644
--- a/parse.y
+++ b/parse.y
@@ -2770,6 +2770,7 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
     const struct vtable *vars;
     struct rb_strterm_struct *strterm;
     struct lex_context ctxt;
+    enum lex_state_e state;
 }
 
 %token <id>
@@ -2934,7 +2935,7 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
 %token tSTAR		"*"
 %token tDSTAR		"**arg"
 %token tAMPER		"&"
-%token tLAMBDA		"->"
+%token <num> tLAMBDA	"->"
 %token tSYMBEG		"symbol literal"
 %token tSTRING_BEG	"string literal"
 %token tXSTRING_BEG	"backtick literal"
@@ -2945,7 +2946,8 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
 %token tQSYMBOLS_BEG	"verbatim symbol list"
 %token tSTRING_END	"terminator"
 %token tSTRING_DEND	"'}'"
-%token tSTRING_DBEG tSTRING_DVAR tLAMBEG tLABEL_END
+%token <state> tSTRING_DBEG "'#{'"
+%token tSTRING_DVAR tLAMBEG tLABEL_END
 
 %token tIGNORED_NL tCOMMENT tEMBDOC_BEG tEMBDOC tEMBDOC_END
 %token tHEREDOC_BEG tHEREDOC_END k__END__
@@ -4641,7 +4643,7 @@ primary		: literal
                   k_end
                     {
                         if (CASE_LABELS_ENABLED_P(p->case_labels)) st_free_table(p->case_labels);
-                        p->case_labels = $<labels>4;
+                        p->case_labels = $4;
                         $$ = NEW_CASE($2, $5, &@$);
                         fixpos($$, $2);
                     /*% ripper: case!($:2, $:5) %*/
@@ -4655,7 +4657,7 @@ primary		: literal
                   k_end
                     {
                         if (p->case_labels) st_free_table(p->case_labels);
-                        p->case_labels = $<labels>3;
+                        p->case_labels = $3;
                         $$ = NEW_CASE2($4, &@$);
                     /*% ripper: case!(Qnil, $:4) %*/
                     }
@@ -5288,13 +5290,12 @@ it_id           :   {
                     }
                 ;
 
-lambda		: tLAMBDA[dyna]
+lambda		: tLAMBDA[lpar]
                     {
                         token_info_push(p, "->", &@1);
-                        $<vars>dyna = dyna_push(p);
-                        $<num>$ = p->lex.lpar_beg;
+                        $$ = dyna_push(p);
                         p->lex.lpar_beg = p->lex.paren_nest;
-                    }[lpar]
+                    }[dyna]<vars>
                   max_numparam numparam it_id allow_exits
                   f_larglist[args]
                     {
@@ -5304,7 +5305,7 @@ lambda		: tLAMBDA[dyna]
                     {
                         int max_numparam = p->max_numparam;
                         ID it_id = p->it_id;
-                        p->lex.lpar_beg = $<num>lpar;
+                        p->lex.lpar_beg = $lpar;
                         p->max_numparam = $max_numparam;
                         p->it_id = $it_id;
                         restore_block_exit(p, $allow_exits);
@@ -5319,7 +5320,7 @@ lambda		: tLAMBDA[dyna]
                         }
                     /*% ripper: lambda!($:args, $:body) %*/
                         numparam_pop(p, $numparam);
-                        dyna_pop(p, $<vars>dyna);
+                        dyna_pop(p, $dyna);
                     }
                 ;
 
@@ -5461,7 +5462,7 @@ brace_block	: '{' brace_body '}'
                     }
                 ;
 
-brace_body	: {$<vars>$ = dyna_push(p);}[dyna]
+brace_body	: {$$ = dyna_push(p);}[dyna]<vars>
                   max_numparam numparam it_id allow_exits
                   opt_block_param[args] compstmt
                     {
@@ -5474,28 +5475,28 @@ brace_body	: {$<vars>$ = dyna_push(p);}[dyna]
                     /*% ripper: brace_block!($:args, $:compstmt) %*/
                         restore_block_exit(p, $allow_exits);
                         numparam_pop(p, $numparam);
-                        dyna_pop(p, $<vars>dyna);
+                        dyna_pop(p, $dyna);
                     }
                 ;
 
 do_body 	:   {
-                        $<vars>$ = dyna_push(p);
+                        $$ = dyna_push(p);
                         CMDARG_PUSH(0);
-                    }[dyna]
+                    }[dyna]<vars>
                   max_numparam numparam it_id allow_exits
                   opt_block_param[args] bodystmt
                     {
                         int max_numparam = p->max_numparam;
                         ID it_id = p->it_id;
                         p->max_numparam = $max_numparam;
-                        p->it_id = $<id>it_id;
+                        p->it_id = $it_id;
                         $args = args_with_numbered(p, $args, max_numparam, it_id);
                         $$ = NEW_ITER($args, $bodystmt, &@$);
                     /*% ripper: do_block!($:args, $:bodystmt) %*/
                         CMDARG_POP();
                         restore_block_exit(p, $allow_exits);
                         numparam_pop(p, $numparam);
-                        dyna_pop(p, $<vars>dyna);
+                        dyna_pop(p, $dyna);
                     }
                 ;
 
@@ -6318,32 +6319,31 @@ string_content	: tSTRING_CONTENT
                         nd_set_line($$, @3.end_pos.lineno);
                     /*% ripper: string_dvar!($:3) %*/
                     }
-                | tSTRING_DBEG[term]
+                | tSTRING_DBEG[state]
                     {
                         CMDARG_PUSH(0);
                         COND_PUSH(0);
                         /* need to backup p->lex.strterm so that a string literal `%!foo,#{ !0 },bar!` can be parsed */
-                        $<strterm>term = p->lex.strterm;
+                        $$ = p->lex.strterm;
                         p->lex.strterm = 0;
-                        $<num>$ = p->lex.state;
                         SET_LEX_STATE(EXPR_BEG);
-                    }[state]
+                    }[term]<strterm>
                     {
-                        $<num>$ = p->lex.brace_nest;
+                        $$ = p->lex.brace_nest;
                         p->lex.brace_nest = 0;
-                    }[brace]
+                    }[brace]<num>
                     {
-                        $<num>$ = p->heredoc_indent;
+                        $$ = p->heredoc_indent;
                         p->heredoc_indent = 0;
-                    }[indent]
+                    }[indent]<num>
                   compstmt string_dend
                     {
                         COND_POP();
                         CMDARG_POP();
-                        p->lex.strterm = $<strterm>term;
-                        SET_LEX_STATE($<num>state);
-                        p->lex.brace_nest = $<num>brace;
-                        p->heredoc_indent = $<num>indent;
+                        p->lex.strterm = $term;
+                        SET_LEX_STATE($state);
+                        p->lex.brace_nest = $brace;
+                        p->heredoc_indent = $indent;
                         p->heredoc_line_indent = -1;
                         if ($compstmt) nd_unset_fl_newline($compstmt);
                         $$ = new_evstr(p, $compstmt, &@$);
@@ -6506,14 +6506,14 @@ f_paren_args	: '(' f_args rparen
 
 f_arglist	: f_paren_args
                 |   {
-                        $<ctxt>$ = p->ctxt;
+                        $$ = p->ctxt;
                         p->ctxt.in_kwarg = 1;
                         p->ctxt.in_argdef = 1;
                         SET_LEX_STATE(p->lex.state|EXPR_LABEL); /* force for args */
-                    }
+                    }<ctxt>
                   f_args term
                     {
-                        p->ctxt.in_kwarg = $<ctxt>1.in_kwarg;
+                        p->ctxt.in_kwarg = $1.in_kwarg;
                         p->ctxt.in_argdef = 0;
                         $$ = $2;
                         SET_LEX_STATE(EXPR_BEG);
@@ -8837,6 +8837,7 @@ parser_peek_variable_name(struct parser_params *p)
       case '{':
         p->lex.pcur = ptr;
         p->command_start = TRUE;
+        yylval.state = p->lex.state;
         return tSTRING_DBEG;
       default:
         return 0;
@@ -11219,6 +11220,7 @@ parser_yylex(struct parser_params *p)
         }
         if (c == '>') {
             SET_LEX_STATE(EXPR_ENDFN);
+            yylval.num = p->lex.lpar_beg;
             return tLAMBDA;
         }
         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '-'))) {

From fd8e6e8c54708c2cfde689afe5762b4e206ffe31 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 19 May 2024 00:27:34 +0900
Subject: [PATCH 084/242] Replace cast tags for `tSTRING_DVAR` with typed
 midrule actions

---
 parse.y | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/parse.y b/parse.y
index de52170cb4e041..38b8a74e4f5b9e 100644
--- a/parse.y
+++ b/parse.y
@@ -6308,13 +6308,13 @@ string_content	: tSTRING_CONTENT
                 | tSTRING_DVAR
                     {
                         /* need to backup p->lex.strterm so that a string literal `%&foo,#$&,bar&` can be parsed */
-                        $<strterm>$ = p->lex.strterm;
+                        $$ = p->lex.strterm;
                         p->lex.strterm = 0;
                         SET_LEX_STATE(EXPR_BEG);
-                    }
+                    }<strterm>
                   string_dvar
                     {
-                        p->lex.strterm = $<strterm>2;
+                        p->lex.strterm = $2;
                         $$ = NEW_EVSTR($3, &@$);
                         nd_set_line($$, @3.end_pos.lineno);
                     /*% ripper: string_dvar!($:3) %*/

From dbbaf871de70243b78e0d2f3d3575351317b5c5c Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 19 May 2024 00:29:00 +0900
Subject: [PATCH 085/242] [DOC] Fix `$<` comment

---
 parse.y | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parse.y b/parse.y
index 38b8a74e4f5b9e..9b363171ed4572 100644
--- a/parse.y
+++ b/parse.y
@@ -10490,7 +10490,7 @@ parse_gvar(struct parser_params *p, const enum lex_state_e last_state)
       case '.': 	/* $.: last read line number */
       case '=': 	/* $=: ignorecase */
       case ':': 	/* $:: load path */
-      case '<': 	/* $<: reading filename */
+      case '<': 	/* $<: default input handle */
       case '>': 	/* $>: default output handle */
       case '\"':	/* $": already loaded files */
         tokadd(p, '$');

From ad636033e2fdafb417873a3cb8667351033307b1 Mon Sep 17 00:00:00 2001
From: Andrew Konchin <andry.konchin@gmail.com>
Date: Thu, 9 May 2024 20:35:01 +0300
Subject: [PATCH 086/242] Update to ruby/spec@6b04c1d

---
 spec/ruby/core/binding/dup_spec.rb            | 17 +++++++
 spec/ruby/core/enumerator/next_values_spec.rb |  8 +++-
 spec/ruby/core/enumerator/peek_values_spec.rb |  8 +++-
 spec/ruby/core/io/pread_spec.rb               |  9 +++-
 spec/ruby/core/io/read_spec.rb                | 15 ++++++
 spec/ruby/core/io/readpartial_spec.rb         |  3 +-
 spec/ruby/core/io/sysread_spec.rb             |  9 +++-
 spec/ruby/core/module/include_spec.rb         | 28 +++++++++++
 spec/ruby/core/module/prepend_spec.rb         | 48 +++++++++++++++++++
 .../core/warning/performance_warning_spec.rb  | 28 +++++++++++
 spec/ruby/language/break_spec.rb              | 19 ++++++++
 spec/ruby/language/execution_spec.rb          |  4 +-
 spec/ruby/language/hash_spec.rb               | 32 +++++++++++++
 spec/ruby/language/keyword_arguments_spec.rb  | 28 +++++++++++
 .../language/regexp/back-references_spec.rb   |  9 ++++
 spec/ruby/language/retry_spec.rb              |  5 +-
 spec/ruby/language/yield_spec.rb              | 12 +++++
 .../library/{ => date}/time/to_date_spec.rb   |  2 +-
 .../{ => datetime}/time/to_datetime_spec.rb   |  2 +-
 .../socket/basicsocket/recv_nonblock_spec.rb  | 16 +++++--
 .../library/socket/basicsocket/recv_spec.rb   | 22 +++++++--
 .../socket/socket/recvfrom_nonblock_spec.rb   | 21 ++++++++
 .../udpsocket/recvfrom_nonblock_spec.rb       |  9 ++++
 .../socket/unixsocket/recvfrom_spec.rb        | 23 +++++++++
 spec/ruby/library/stringio/shared/read.rb     | 20 +++++++-
 spec/ruby/optional/capi/class_spec.rb         | 12 +++++
 spec/ruby/optional/capi/ext/class_spec.c      |  5 ++
 spec/ruby/optional/capi/ext/gc_spec.c         | 10 ++++
 spec/ruby/optional/capi/ext/object_spec.c     | 16 +++----
 spec/ruby/optional/capi/gc_spec.rb            |  4 ++
 spec/ruby/shared/kernel/at_exit.rb            |  6 +++
 31 files changed, 425 insertions(+), 25 deletions(-)
 create mode 100644 spec/ruby/core/warning/performance_warning_spec.rb
 rename spec/ruby/library/{ => date}/time/to_date_spec.rb (97%)
 rename spec/ruby/library/{ => datetime}/time/to_datetime_spec.rb (97%)

diff --git a/spec/ruby/core/binding/dup_spec.rb b/spec/ruby/core/binding/dup_spec.rb
index 55fac6e3332a84..4eff66bd9a4cc9 100644
--- a/spec/ruby/core/binding/dup_spec.rb
+++ b/spec/ruby/core/binding/dup_spec.rb
@@ -10,4 +10,21 @@
     bind.frozen?.should == true
     bind.dup.frozen?.should == false
   end
+
+  it "retains original binding variables but the list is distinct" do
+    bind1 = binding
+    eval "a = 1", bind1
+
+    bind2 = bind1.dup
+    eval("a = 2", bind2)
+    eval("a", bind1).should == 2
+    eval("a", bind2).should == 2
+
+    eval("b = 2", bind2)
+    -> { eval("b", bind1) }.should raise_error(NameError)
+    eval("b", bind2).should == 2
+
+    bind1.local_variables.sort.should == [:a, :bind1, :bind2]
+    bind2.local_variables.sort.should == [:a, :b, :bind1, :bind2]
+  end
 end
diff --git a/spec/ruby/core/enumerator/next_values_spec.rb b/spec/ruby/core/enumerator/next_values_spec.rb
index 201b5d323ffbf8..2202700c588832 100644
--- a/spec/ruby/core/enumerator/next_values_spec.rb
+++ b/spec/ruby/core/enumerator/next_values_spec.rb
@@ -11,6 +11,7 @@ def o.each
       yield :e1, :e2, :e3
       yield nil
       yield
+      yield [:f1, :f2]
     end
 
     @e = o.to_enum
@@ -48,8 +49,13 @@ def o.each
     @e.next_values.should == []
   end
 
-  it "raises StopIteration if called on a finished enumerator" do
+  it "returns an array of array if yield is called with an array" do
     7.times { @e.next }
+    @e.next_values.should == [[:f1, :f2]]
+  end
+
+  it "raises StopIteration if called on a finished enumerator" do
+    8.times { @e.next }
     -> { @e.next_values }.should raise_error(StopIteration)
   end
 end
diff --git a/spec/ruby/core/enumerator/peek_values_spec.rb b/spec/ruby/core/enumerator/peek_values_spec.rb
index 7865546515d460..8b84fc8afcde8f 100644
--- a/spec/ruby/core/enumerator/peek_values_spec.rb
+++ b/spec/ruby/core/enumerator/peek_values_spec.rb
@@ -11,6 +11,7 @@ def o.each
       yield :e1, :e2, :e3
       yield nil
       yield
+      yield [:f1, :f2]
     end
 
     @e = o.to_enum
@@ -50,8 +51,13 @@ def o.each
     @e.peek_values.should == []
   end
 
-  it "raises StopIteration if called on a finished enumerator" do
+  it "returns an array of array if yield is called with an array" do
     7.times { @e.next }
+    @e.peek_values.should == [[:f1, :f2]]
+  end
+
+  it "raises StopIteration if called on a finished enumerator" do
+    8.times { @e.next }
     -> { @e.peek_values }.should raise_error(StopIteration)
   end
 end
diff --git a/spec/ruby/core/io/pread_spec.rb b/spec/ruby/core/io/pread_spec.rb
index 28afc80e5c614f..6d93b432c2636d 100644
--- a/spec/ruby/core/io/pread_spec.rb
+++ b/spec/ruby/core/io/pread_spec.rb
@@ -22,7 +22,7 @@
 
     it "accepts a length, an offset, and an output buffer" do
       buffer = +"foo"
-      @file.pread(3, 4, buffer)
+      @file.pread(3, 4, buffer).should.equal?(buffer)
       buffer.should == "567"
     end
 
@@ -38,6 +38,13 @@
       buffer.should == "12345"
     end
 
+    it "preserves the encoding of the given buffer" do
+      buffer = ''.encode(Encoding::ISO_8859_1)
+      @file.pread(10, 0, buffer)
+
+      buffer.encoding.should == Encoding::ISO_8859_1
+    end
+
     it "does not advance the file pointer" do
       @file.pread(4, 0).should == "1234"
       @file.read.should == "1234567890"
diff --git a/spec/ruby/core/io/read_spec.rb b/spec/ruby/core/io/read_spec.rb
index eb3652e692a581..8741d9f0179a85 100644
--- a/spec/ruby/core/io/read_spec.rb
+++ b/spec/ruby/core/io/read_spec.rb
@@ -376,6 +376,21 @@
     buf.should == @contents[0..4]
   end
 
+  it "preserves the encoding of the given buffer" do
+    buffer = ''.encode(Encoding::ISO_8859_1)
+    @io.read(10, buffer)
+
+    buffer.encoding.should == Encoding::ISO_8859_1
+  end
+
+  # https://bugs.ruby-lang.org/issues/20416
+  it "does not preserve the encoding of the given buffer when max length is not provided" do
+    buffer = ''.encode(Encoding::ISO_8859_1)
+    @io.read(nil, buffer)
+
+    buffer.encoding.should_not == Encoding::ISO_8859_1
+  end
+
   it "returns the given buffer" do
     buf = +""
 
diff --git a/spec/ruby/core/io/readpartial_spec.rb b/spec/ruby/core/io/readpartial_spec.rb
index 0060beb54504a5..0852f20b2da83b 100644
--- a/spec/ruby/core/io/readpartial_spec.rb
+++ b/spec/ruby/core/io/readpartial_spec.rb
@@ -62,7 +62,7 @@
     buffer = +"existing content"
     @wr.write("hello world")
     @wr.close
-    @rd.readpartial(11, buffer)
+    @rd.readpartial(11, buffer).should.equal?(buffer)
     buffer.should == "hello world"
   end
 
@@ -106,6 +106,7 @@
     @wr.write("abc")
     @wr.close
     @rd.readpartial(10, buffer)
+
     buffer.encoding.should == Encoding::ISO_8859_1
   end
 end
diff --git a/spec/ruby/core/io/sysread_spec.rb b/spec/ruby/core/io/sysread_spec.rb
index 003bb9eb94911a..8851214283ca54 100644
--- a/spec/ruby/core/io/sysread_spec.rb
+++ b/spec/ruby/core/io/sysread_spec.rb
@@ -97,7 +97,7 @@
 
   it "discards the existing buffer content upon successful read" do
     buffer = +"existing content"
-    @file.sysread(11, buffer)
+    @file.sysread(11, buffer).should.equal?(buffer)
     buffer.should == "01234567890"
   end
 
@@ -107,6 +107,13 @@
     -> { @file.sysread(1, buffer) }.should raise_error(EOFError)
     buffer.should be_empty
   end
+
+  it "preserves the encoding of the given buffer" do
+    buffer = ''.encode(Encoding::ISO_8859_1)
+    string = @file.sysread(10, buffer)
+
+    buffer.encoding.should == Encoding::ISO_8859_1
+  end
 end
 
 describe "IO#sysread" do
diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb
index c073bc31ca0eea..78f6b410317142 100644
--- a/spec/ruby/core/module/include_spec.rb
+++ b/spec/ruby/core/module/include_spec.rb
@@ -47,6 +47,34 @@ def self.append_features(mod)
     -> { ModuleSpecs::SubclassSpec.include(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
   end
 
+  ruby_version_is ""..."3.2" do
+    it "raises ArgumentError when the argument is a refinement" do
+      refinement = nil
+
+      Module.new do
+        refine String do
+          refinement = self
+        end
+      end
+
+      -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")
+    end
+  end
+
+  ruby_version_is "3.2" do
+    it "raises a TypeError when the argument is a refinement" do
+      refinement = nil
+
+      Module.new do
+        refine String do
+          refinement = self
+        end
+      end
+
+      -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(TypeError, "Cannot include refinement")
+    end
+  end
+
   it "imports constants to modules and classes" do
     ModuleSpecs::A.constants.should include(:CONSTANT_A)
     ModuleSpecs::B.constants.should include(:CONSTANT_A, :CONSTANT_B)
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
index c90fa9700ec3b4..b40d12f0deba2d 100644
--- a/spec/ruby/core/module/prepend_spec.rb
+++ b/spec/ruby/core/module/prepend_spec.rb
@@ -75,6 +75,26 @@ def foo
     foo.call.should == 'm'
   end
 
+  it "updates the optimized method when a prepended module is updated" do
+    out = ruby_exe(<<~RUBY)
+    module M; end
+    class Integer
+      prepend M
+    end
+    l = -> { 1 + 2 }
+    p l.call
+    M.module_eval do
+      def +(o)
+        $called = true
+        super(o)
+      end
+    end
+    p l.call
+    p $called
+    RUBY
+    out.should == "3\n3\ntrue\n"
+  end
+
   it "updates the method when there is a base included method and the prepended module overrides it" do
     base_module = Module.new do
       def foo
@@ -415,6 +435,34 @@ module M
     -> { ModuleSpecs::SubclassSpec.prepend(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
   end
 
+  ruby_version_is ""..."3.2" do
+    it "raises ArgumentError when the argument is a refinement" do
+      refinement = nil
+
+      Module.new do
+        refine String do
+          refinement = self
+        end
+      end
+
+      -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")
+    end
+  end
+
+  ruby_version_is "3.2" do
+    it "raises a TypeError when the argument is a refinement" do
+      refinement = nil
+
+      Module.new do
+        refine String do
+          refinement = self
+        end
+      end
+
+      -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(TypeError, "Cannot prepend refinement")
+    end
+  end
+
   it "imports constants" do
     m1 = Module.new
     m1::MY_CONSTANT = 1
diff --git a/spec/ruby/core/warning/performance_warning_spec.rb b/spec/ruby/core/warning/performance_warning_spec.rb
new file mode 100644
index 00000000000000..ab0badcd3d7f33
--- /dev/null
+++ b/spec/ruby/core/warning/performance_warning_spec.rb
@@ -0,0 +1,28 @@
+require_relative '../../spec_helper'
+
+
+describe "Performance warnings" do
+  guard -> { ruby_version_is("3.4") || RUBY_ENGINE == "truffleruby" } do
+    # Optimising Integer, Float or Symbol methods is kind of implementation detail
+    # but multiple implementations do so. So it seems reasonable to have a test case
+    # for at least one such common method.
+    # See https://bugs.ruby-lang.org/issues/20429
+    context "when redefined optimised methods" do
+      it "emits performance warning for redefining Integer#+" do
+        code = <<~CODE
+          Warning[:performance] = true
+
+          class Integer
+            ORIG_METHOD = instance_method(:+)
+
+            def +(...)
+              ORIG_METHOD.bind(self).call(...)
+            end
+          end
+        CODE
+
+        ruby_exe(code, args: "2>&1").should.include?("warning: Redefining 'Integer#+' disables interpreter and JIT optimizations")
+      end
+    end
+  end
+end
diff --git a/spec/ruby/language/break_spec.rb b/spec/ruby/language/break_spec.rb
index e725e77e80d0b3..7e5b6fb32859c2 100644
--- a/spec/ruby/language/break_spec.rb
+++ b/spec/ruby/language/break_spec.rb
@@ -252,6 +252,25 @@ def mid(&b)
   end
 end
 
+describe "The break statement in a method" do
+  it "is invalid and raises a SyntaxError" do
+    -> {
+      eval("def m; break; end")
+    }.should raise_error(SyntaxError)
+  end
+end
+
+describe "The break statement in a module literal" do
+  it "is invalid and raises a SyntaxError" do
+    code = <<~RUBY
+      module BreakSpecs:ModuleWithBreak
+        break
+      end
+    RUBY
+
+    -> { eval(code) }.should raise_error(SyntaxError)
+  end
+end
 
 # TODO: Rewrite all the specs from here to the end of the file in the style
 # above.
diff --git a/spec/ruby/language/execution_spec.rb b/spec/ruby/language/execution_spec.rb
index ef1de38899809d..51bcde62e8c745 100644
--- a/spec/ruby/language/execution_spec.rb
+++ b/spec/ruby/language/execution_spec.rb
@@ -38,7 +38,7 @@
 
     2.times do
       runner.instance_exec do
-        `test #{:command}`
+        `test #{:command}` # rubocop:disable Lint/LiteralInInterpolation
       end
     end
 
@@ -84,7 +84,7 @@
 
     2.times do
       runner.instance_exec do
-        %x{test #{:command}}
+        %x{test #{:command}} # rubocop:disable Lint/LiteralInInterpolation
       end
     end
 
diff --git a/spec/ruby/language/hash_spec.rb b/spec/ruby/language/hash_spec.rb
index a7631fb0d6b6fb..068ac0f39c6a5f 100644
--- a/spec/ruby/language/hash_spec.rb
+++ b/spec/ruby/language/hash_spec.rb
@@ -86,6 +86,30 @@
     -> { eval("{:a ==> 1}") }.should raise_error(SyntaxError)
   end
 
+  it "recognizes '!' at the end of the key" do
+    eval("{:a! =>1}").should == {:"a!" => 1}
+    eval("{:a! => 1}").should == {:"a!" => 1}
+
+    eval("{a!:1}").should == {:"a!" => 1}
+    eval("{a!: 1}").should == {:"a!" => 1}
+  end
+
+  it "raises a SyntaxError if there is no space between `!` and `=>`" do
+    -> { eval("{:a!=> 1}") }.should raise_error(SyntaxError)
+  end
+
+  it "recognizes '?' at the end of the key" do
+    eval("{:a? =>1}").should == {:"a?" => 1}
+    eval("{:a? => 1}").should == {:"a?" => 1}
+
+    eval("{a?:1}").should == {:"a?" => 1}
+    eval("{a?: 1}").should == {:"a?" => 1}
+  end
+
+  it "raises a SyntaxError if there is no space between `?` and `=>`" do
+    -> { eval("{:a?=> 1}") }.should raise_error(SyntaxError)
+  end
+
   it "constructs a new hash with the given elements" do
     {foo: 123}.should == {foo: 123}
     h = {rbx: :cool, specs: 'fail_sometimes'}
@@ -271,6 +295,14 @@ def foo(val)
 
         a.new.foo(1).should == {bar: "baz", val: 1}
       end
+
+      it "raises a SyntaxError when the hash key ends with `!`" do
+        -> { eval("{a!:}") }.should raise_error(SyntaxError, /identifier a! is not valid to get/)
+      end
+
+      it "raises a SyntaxError when the hash key ends with `?`" do
+        -> { eval("{a?:}") }.should raise_error(SyntaxError, /identifier a\? is not valid to get/)
+      end
     end
   end
 end
diff --git a/spec/ruby/language/keyword_arguments_spec.rb b/spec/ruby/language/keyword_arguments_spec.rb
index ffb5b1fab06cc4..8668799d26cd1e 100644
--- a/spec/ruby/language/keyword_arguments_spec.rb
+++ b/spec/ruby/language/keyword_arguments_spec.rb
@@ -395,4 +395,32 @@ def n(*args) # Note the missing ruby2_keywords here
       end
     end
   end
+
+  context "in define_method(name, &proc)" do
+    # This tests that a free-standing proc used in define_method and converted to ruby2_keywords adopts that logic.
+    # See jruby/jruby#8119 for a case where aggressive JIT optimization broke later ruby2_keywords changes.
+    it "works with ruby2_keywords" do
+      m = Class.new do
+        def bar(a, foo: nil)
+          [a, foo]
+        end
+
+        # define_method and ruby2_keywords using send to avoid peephole optimizations
+        def self.setup
+          pr = make_proc
+          send :define_method, :foo, &pr
+          send :ruby2_keywords, :foo
+        end
+
+        # create proc in isolated method to force jit compilation on some implementations
+        def self.make_proc
+          proc { |a, *args| bar(a, *args) }
+        end
+      end
+
+      m.setup
+
+      m.new.foo(1, foo:2).should == [1, 2]
+    end
+  end
 end
diff --git a/spec/ruby/language/regexp/back-references_spec.rb b/spec/ruby/language/regexp/back-references_spec.rb
index 26750c20c59a86..627c8daacefa42 100644
--- a/spec/ruby/language/regexp/back-references_spec.rb
+++ b/spec/ruby/language/regexp/back-references_spec.rb
@@ -22,6 +22,15 @@
     $10.should == "0"
   end
 
+  it "returns nil for numbered variable with too large index" do
+    -> {
+      eval(<<~CODE).should == nil
+        "a" =~ /(.)/
+        eval('$4294967296')
+      CODE
+    }.should complain(/warning: ('|`)\$4294967296' is too big for a number variable, always nil/)
+  end
+
   it "will not clobber capture variables across threads" do
     cap1, cap2, cap3 = nil
     "foo" =~ /(o+)/
diff --git a/spec/ruby/language/retry_spec.rb b/spec/ruby/language/retry_spec.rb
index ee5377946f7ef9..669d5f0ff51904 100644
--- a/spec/ruby/language/retry_spec.rb
+++ b/spec/ruby/language/retry_spec.rb
@@ -31,8 +31,11 @@
     results.should == [1, 2, 3, 1, 2, 4, 5, 6, 4, 5]
   end
 
-  it "raises a SyntaxError when used outside of a begin statement" do
+  it "raises a SyntaxError when used outside of a rescue statement" do
     -> { eval 'retry' }.should raise_error(SyntaxError)
+    -> { eval 'begin; retry; end' }.should raise_error(SyntaxError)
+    -> { eval 'def m; retry; end' }.should raise_error(SyntaxError)
+    -> { eval 'module RetrySpecs; retry; end' }.should raise_error(SyntaxError)
   end
 end
 
diff --git a/spec/ruby/language/yield_spec.rb b/spec/ruby/language/yield_spec.rb
index 5283517636d202..e125cf8e738bea 100644
--- a/spec/ruby/language/yield_spec.rb
+++ b/spec/ruby/language/yield_spec.rb
@@ -206,3 +206,15 @@ class << Object.new
     -> { eval(code) }.should raise_error(SyntaxError, /Invalid yield/)
   end
 end
+
+describe "Using yield in a module literal" do
+  it 'raises a SyntaxError' do
+    code = <<~RUBY
+      module YieldSpecs::ModuleWithYield
+        yield
+      end
+    RUBY
+
+    -> { eval(code) }.should raise_error(SyntaxError, /Invalid yield/)
+  end
+end
diff --git a/spec/ruby/library/time/to_date_spec.rb b/spec/ruby/library/date/time/to_date_spec.rb
similarity index 97%
rename from spec/ruby/library/time/to_date_spec.rb
rename to spec/ruby/library/date/time/to_date_spec.rb
index baeafe0847a7d2..f9132da2890e92 100644
--- a/spec/ruby/library/time/to_date_spec.rb
+++ b/spec/ruby/library/date/time/to_date_spec.rb
@@ -1,5 +1,5 @@
 
-require_relative '../../spec_helper'
+require_relative '../../../spec_helper'
 require 'time'
 
 describe "Time#to_date" do
diff --git a/spec/ruby/library/time/to_datetime_spec.rb b/spec/ruby/library/datetime/time/to_datetime_spec.rb
similarity index 97%
rename from spec/ruby/library/time/to_datetime_spec.rb
rename to spec/ruby/library/datetime/time/to_datetime_spec.rb
index 9c44f38e5c2ff1..1125dbe851c8fa 100644
--- a/spec/ruby/library/time/to_datetime_spec.rb
+++ b/spec/ruby/library/datetime/time/to_datetime_spec.rb
@@ -1,4 +1,4 @@
-require_relative '../../spec_helper'
+require_relative '../../../spec_helper'
 require 'time'
 require 'date'
 date_version = defined?(Date::VERSION) ? Date::VERSION : '3.1.0'
diff --git a/spec/ruby/library/socket/basicsocket/recv_nonblock_spec.rb b/spec/ruby/library/socket/basicsocket/recv_nonblock_spec.rb
index 17c846054df17a..df42c116fb33f1 100644
--- a/spec/ruby/library/socket/basicsocket/recv_nonblock_spec.rb
+++ b/spec/ruby/library/socket/basicsocket/recv_nonblock_spec.rb
@@ -52,9 +52,19 @@
       @s2.send("data", 0, @s1.getsockname)
       IO.select([@s1], nil, nil, 2)
 
-      buf = +"foo"
-      @s1.recv_nonblock(5, 0, buf)
-      buf.should == "data"
+      buffer = +"foo"
+      @s1.recv_nonblock(5, 0, buffer).should.equal?(buffer)
+      buffer.should == "data"
+    end
+
+    it "preserves the encoding of the given buffer" do
+      @s1.bind(Socket.pack_sockaddr_in(0, ip_address))
+      @s2.send("data", 0, @s1.getsockname)
+      IO.select([@s1], nil, nil, 2)
+
+      buffer = ''.encode(Encoding::ISO_8859_1)
+      @s1.recv_nonblock(5, 0, buffer)
+      buffer.encoding.should == Encoding::ISO_8859_1
     end
 
     it "does not block if there's no data available" do
diff --git a/spec/ruby/library/socket/basicsocket/recv_spec.rb b/spec/ruby/library/socket/basicsocket/recv_spec.rb
index 9fe8c52f9a5233..e82a357d3dfd35 100644
--- a/spec/ruby/library/socket/basicsocket/recv_spec.rb
+++ b/spec/ruby/library/socket/basicsocket/recv_spec.rb
@@ -100,13 +100,29 @@
     socket.write("data")
 
     client = @server.accept
-    buf = +"foo"
+    buffer = +"foo"
     begin
-      client.recv(4, 0, buf)
+      client.recv(4, 0, buffer).should.equal?(buffer)
     ensure
       client.close
     end
-    buf.should == "data"
+    buffer.should == "data"
+
+    socket.close
+  end
+
+  it "preserves the encoding of the given buffer" do
+    socket = TCPSocket.new('127.0.0.1', @port)
+    socket.write("data")
+
+    client = @server.accept
+    buffer = ''.encode(Encoding::ISO_8859_1)
+    begin
+      client.recv(4, 0, buffer)
+    ensure
+      client.close
+    end
+    buffer.encoding.should == Encoding::ISO_8859_1
 
     socket.close
   end
diff --git a/spec/ruby/library/socket/socket/recvfrom_nonblock_spec.rb b/spec/ruby/library/socket/socket/recvfrom_nonblock_spec.rb
index 94f58ac49f4ac6..5596f91bb86b07 100644
--- a/spec/ruby/library/socket/socket/recvfrom_nonblock_spec.rb
+++ b/spec/ruby/library/socket/socket/recvfrom_nonblock_spec.rb
@@ -52,6 +52,27 @@
           end
         end
 
+        it "allows an output buffer as third argument" do
+          @client.write('hello')
+
+          IO.select([@server])
+          buffer = +''
+          message, = @server.recvfrom_nonblock(5, 0, buffer)
+
+          message.should.equal?(buffer)
+          buffer.should == 'hello'
+        end
+
+        it "preserves the encoding of the given buffer" do
+          @client.write('hello')
+
+          IO.select([@server])
+          buffer = ''.encode(Encoding::ISO_8859_1)
+          @server.recvfrom_nonblock(5, 0, buffer)
+
+          buffer.encoding.should == Encoding::ISO_8859_1
+        end
+
         describe 'the returned data' do
           it 'is the same as the sent data' do
             5.times do
diff --git a/spec/ruby/library/socket/udpsocket/recvfrom_nonblock_spec.rb b/spec/ruby/library/socket/udpsocket/recvfrom_nonblock_spec.rb
index 650a061221b8c1..b8040995897c34 100644
--- a/spec/ruby/library/socket/udpsocket/recvfrom_nonblock_spec.rb
+++ b/spec/ruby/library/socket/udpsocket/recvfrom_nonblock_spec.rb
@@ -58,6 +58,15 @@
             buffer.should == 'h'
           end
 
+          it "preserves the encoding of the given buffer" do
+            buffer = ''.encode(Encoding::ISO_8859_1)
+            IO.select([@server])
+            message, = @server.recvfrom_nonblock(1, 0, buffer)
+
+            message.should.equal?(buffer)
+            buffer.encoding.should == Encoding::ISO_8859_1
+          end
+
           describe 'the returned Array' do
             before do
               IO.select([@server])
diff --git a/spec/ruby/library/socket/unixsocket/recvfrom_spec.rb b/spec/ruby/library/socket/unixsocket/recvfrom_spec.rb
index fedf74bb2fa2ac..d849fdc302646b 100644
--- a/spec/ruby/library/socket/unixsocket/recvfrom_spec.rb
+++ b/spec/ruby/library/socket/unixsocket/recvfrom_spec.rb
@@ -31,6 +31,29 @@
       sock.close
     end
 
+    it "allows an output buffer as third argument" do
+      buffer = +''
+
+      @client.send("foobar", 0)
+      sock = @server.accept
+      message, = sock.recvfrom(6, 0, buffer)
+      sock.close
+
+      message.should.equal?(buffer)
+      buffer.should == "foobar"
+    end
+
+    it "preserves the encoding of the given buffer" do
+      buffer = ''.encode(Encoding::ISO_8859_1)
+
+      @client.send("foobar", 0)
+      sock = @server.accept
+      sock.recvfrom(6, 0, buffer)
+      sock.close
+
+      buffer.encoding.should == Encoding::ISO_8859_1
+    end
+
     it "uses different message options" do
       @client.send("foobar", Socket::MSG_PEEK)
       sock = @server.accept
diff --git a/spec/ruby/library/stringio/shared/read.rb b/spec/ruby/library/stringio/shared/read.rb
index e3840786d902fa..8ef6ec273427a1 100644
--- a/spec/ruby/library/stringio/shared/read.rb
+++ b/spec/ruby/library/stringio/shared/read.rb
@@ -11,10 +11,28 @@
   end
 
   it "reads length bytes and writes them to the buffer String" do
-    @io.send(@method, 7, buffer = +"")
+    @io.send(@method, 7, buffer = +"").should.equal?(buffer)
     buffer.should == "example"
   end
 
+  ruby_version_is ""..."3.4" do
+    it "does not preserve the encoding of the given buffer" do
+      buffer = ''.encode(Encoding::ISO_8859_1)
+      @io.send(@method, 7, buffer)
+
+      buffer.encoding.should_not == Encoding::ISO_8859_1
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "preserves the encoding of the given buffer" do
+      buffer = ''.encode(Encoding::ISO_8859_1)
+      @io.send(@method, 7, buffer)
+
+      buffer.encoding.should == Encoding::ISO_8859_1
+    end
+  end
+
   it "tries to convert the passed buffer Object to a String using #to_str" do
     obj = mock("to_str")
     obj.should_receive(:to_str).and_return(buffer = +"")
diff --git a/spec/ruby/optional/capi/class_spec.rb b/spec/ruby/optional/capi/class_spec.rb
index d0a9913570ddb2..a231245ebe8158 100644
--- a/spec/ruby/optional/capi/class_spec.rb
+++ b/spec/ruby/optional/capi/class_spec.rb
@@ -487,4 +487,16 @@ def obj.some_method() end
       @s.rb_class_real(0).should == 0
     end
   end
+
+  describe "rb_class_get_superclass" do
+    it "returns parent class for a provided class" do
+      a = Class.new
+      @s.rb_class_get_superclass(Class.new(a)).should == a
+    end
+
+    it "returns false when there is no parent class" do
+      @s.rb_class_get_superclass(BasicObject).should == false
+      @s.rb_class_get_superclass(Module.new).should == false
+    end
+  end
 end
diff --git a/spec/ruby/optional/capi/ext/class_spec.c b/spec/ruby/optional/capi/ext/class_spec.c
index f376534924cf1c..c13f02ecf23c79 100644
--- a/spec/ruby/optional/capi/ext/class_spec.c
+++ b/spec/ruby/optional/capi/ext/class_spec.c
@@ -79,6 +79,10 @@ static VALUE class_spec_rb_class_real(VALUE self, VALUE object) {
   }
 }
 
+static VALUE class_spec_rb_class_get_superclass(VALUE self, VALUE klass) {
+  return rb_class_get_superclass(klass);
+}
+
 static VALUE class_spec_rb_class_superclass(VALUE self, VALUE klass) {
   return rb_class_superclass(klass);
 }
@@ -160,6 +164,7 @@ void Init_class_spec(void) {
   rb_define_method(cls, "rb_class_new_instance_kw", class_spec_rb_class_new_instance_kw, 2);
 #endif
   rb_define_method(cls, "rb_class_real", class_spec_rb_class_real, 1);
+  rb_define_method(cls, "rb_class_get_superclass", class_spec_rb_class_get_superclass, 1);
   rb_define_method(cls, "rb_class_superclass", class_spec_rb_class_superclass, 1);
   rb_define_method(cls, "rb_cvar_defined", class_spec_cvar_defined, 2);
   rb_define_method(cls, "rb_cvar_get", class_spec_cvar_get, 2);
diff --git a/spec/ruby/optional/capi/ext/gc_spec.c b/spec/ruby/optional/capi/ext/gc_spec.c
index 1392bc6ee668da..2637ad27ac570a 100644
--- a/spec/ruby/optional/capi/ext/gc_spec.c
+++ b/spec/ruby/optional/capi/ext/gc_spec.c
@@ -16,6 +16,8 @@ VALUE registered_after_rb_global_variable_bignum;
 VALUE registered_after_rb_global_variable_float;
 VALUE rb_gc_register_address_outside_init;
 
+VALUE rb_gc_register_mark_object_not_referenced_float;
+
 static VALUE registered_tagged_address(VALUE self) {
   return registered_tagged_value;
 }
@@ -90,6 +92,10 @@ static VALUE gc_spec_rb_gc_register_mark_object(VALUE self, VALUE obj) {
   return Qnil;
 }
 
+static VALUE gc_spec_rb_gc_register_mark_object_not_referenced_float(VALUE self) {
+  return rb_gc_register_mark_object_not_referenced_float;
+}
+
 void Init_gc_spec(void) {
   VALUE cls = rb_define_class("CApiGCSpecs", rb_cObject);
 
@@ -115,6 +121,9 @@ void Init_gc_spec(void) {
   registered_after_rb_global_variable_float = DBL2NUM(6.28);
   rb_global_variable(&registered_after_rb_global_variable_float);
 
+  rb_gc_register_mark_object_not_referenced_float = DBL2NUM(1.61);
+  rb_gc_register_mark_object(rb_gc_register_mark_object_not_referenced_float);
+
   rb_define_method(cls, "registered_tagged_address", registered_tagged_address, 0);
   rb_define_method(cls, "registered_reference_address", registered_reference_address, 0);
   rb_define_method(cls, "registered_before_rb_gc_register_address", get_registered_before_rb_gc_register_address, 0);
@@ -131,6 +140,7 @@ void Init_gc_spec(void) {
   rb_define_method(cls, "rb_gc", gc_spec_rb_gc, 0);
   rb_define_method(cls, "rb_gc_adjust_memory_usage", gc_spec_rb_gc_adjust_memory_usage, 1);
   rb_define_method(cls, "rb_gc_register_mark_object", gc_spec_rb_gc_register_mark_object, 1);
+  rb_define_method(cls, "rb_gc_register_mark_object_not_referenced_float", gc_spec_rb_gc_register_mark_object_not_referenced_float, 0);
   rb_define_method(cls, "rb_gc_latest_gc_info", gc_spec_rb_gc_latest_gc_info, 1);
 }
 
diff --git a/spec/ruby/optional/capi/ext/object_spec.c b/spec/ruby/optional/capi/ext/object_spec.c
index 8aa98cc5ce24c1..aa60662e1e3bb2 100644
--- a/spec/ruby/optional/capi/ext/object_spec.c
+++ b/spec/ruby/optional/capi/ext/object_spec.c
@@ -390,22 +390,22 @@ static VALUE speced_allocator(VALUE klass) {
   return instance;
 }
 
-static VALUE define_alloc_func(VALUE self, VALUE klass) {
+static VALUE object_spec_rb_define_alloc_func(VALUE self, VALUE klass) {
   rb_define_alloc_func(klass, speced_allocator);
   return Qnil;
 }
 
-static VALUE undef_alloc_func(VALUE self, VALUE klass) {
+static VALUE object_spec_rb_undef_alloc_func(VALUE self, VALUE klass) {
   rb_undef_alloc_func(klass);
   return Qnil;
 }
 
-static VALUE speced_allocator_p(VALUE self, VALUE klass) {
+static VALUE object_spec_speced_allocator_p(VALUE self, VALUE klass) {
   rb_alloc_func_t allocator = rb_get_alloc_func(klass);
   return (allocator == speced_allocator) ? Qtrue : Qfalse;
 }
 
-static VALUE custom_alloc_func_p(VALUE self, VALUE klass) {
+static VALUE object_spec_custom_alloc_func_p(VALUE self, VALUE klass) {
   rb_alloc_func_t allocator = rb_get_alloc_func(klass);
   return allocator ? Qtrue : Qfalse;
 }
@@ -485,10 +485,10 @@ void Init_object_spec(void) {
   rb_define_method(cls, "rb_ivar_defined", object_spec_rb_ivar_defined, 2);
   rb_define_method(cls, "rb_copy_generic_ivar", object_spec_rb_copy_generic_ivar, 2);
   rb_define_method(cls, "rb_free_generic_ivar", object_spec_rb_free_generic_ivar, 1);
-  rb_define_method(cls, "rb_define_alloc_func", define_alloc_func, 1);
-  rb_define_method(cls, "rb_undef_alloc_func", undef_alloc_func, 1);
-  rb_define_method(cls, "speced_allocator?", speced_allocator_p, 1);
-  rb_define_method(cls, "custom_alloc_func?", custom_alloc_func_p, 1);
+  rb_define_method(cls, "rb_define_alloc_func", object_spec_rb_define_alloc_func, 1);
+  rb_define_method(cls, "rb_undef_alloc_func", object_spec_rb_undef_alloc_func, 1);
+  rb_define_method(cls, "speced_allocator?", object_spec_speced_allocator_p, 1);
+  rb_define_method(cls, "custom_alloc_func?", object_spec_custom_alloc_func_p, 1);
   rb_define_method(cls, "not_implemented_method", rb_f_notimplement, -1);
   rb_define_method(cls, "rb_ivar_foreach", object_spec_rb_ivar_foreach, 1);
 }
diff --git a/spec/ruby/optional/capi/gc_spec.rb b/spec/ruby/optional/capi/gc_spec.rb
index aaced56483a0cc..d9661328ab39a0 100644
--- a/spec/ruby/optional/capi/gc_spec.rb
+++ b/spec/ruby/optional/capi/gc_spec.rb
@@ -108,6 +108,10 @@
     it "can be called with an object" do
       @f.rb_gc_register_mark_object(Object.new).should be_nil
     end
+
+    it "keeps the value alive even if the value is not referenced by any Ruby object" do
+      @f.rb_gc_register_mark_object_not_referenced_float.should == 1.61
+    end
   end
 
   describe "rb_gc_latest_gc_info" do
diff --git a/spec/ruby/shared/kernel/at_exit.rb b/spec/ruby/shared/kernel/at_exit.rb
index 16d41cb01c93b1..29db79bb391428 100644
--- a/spec/ruby/shared/kernel/at_exit.rb
+++ b/spec/ruby/shared/kernel/at_exit.rb
@@ -30,6 +30,12 @@
     result.lines.should.include?("The exception matches: true (message=foo)\n")
   end
 
+  it "gives access to an exception raised in a previous handler" do
+    code = "#{@method} { print '$!.message = ' + $!.message }; #{@method} { raise 'foo' }"
+    result = ruby_exe(code, args: "2>&1", exit_status: 1)
+    result.lines.should.include?("$!.message = foo")
+  end
+
   it "both exceptions in a handler and in the main script are printed" do
     code = "#{@method} { raise 'at_exit_error' }; raise 'main_script_error'"
     result = ruby_exe(code, args: "2>&1", exit_status: 1)

From 7afc16aa48beb093b06eb978bc430f90dd771690 Mon Sep 17 00:00:00 2001
From: KJ Tsanaktsidis <ktsanaktsidis@zendesk.com>
Date: Sat, 18 May 2024 18:37:49 +0900
Subject: [PATCH 087/242] Inline RB_VM_SAVE_MACHINE_CONTEXT into
 BLOCKING_REGION

There's an exhaustive explanation of this in the linked redmine bug, but
the short version is as follows:

blocking_region_begin can spill callee-saved registers to the stack for
its own use. That means they're not saved to ec->machine by the call to
setjmp, since by that point they're already on the stack and new,
different values are in the real registers. ec->machine's end-of-stack
pointer is also bumped to accomodate this, BUT, after
blocking_region_begin returns, that points past the end of the stack!

As far as C is concerned, that's fine; the callee-saved registers are
restored when blocking_region_begin returns. But, if another thread
triggers GC, it is relying on finding references to Ruby objects by
walking the stack region pointed to by ec->machine.

If the C code in exec; subsequently does things that use that stack
memory, then the value will be overwritten and the GC might prematurely
collect something it shouldn't.

[Bug #20493]
---
 thread.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/thread.c b/thread.c
index b8ba61e188bb2e..80537fd41dfee9 100644
--- a/thread.c
+++ b/thread.c
@@ -197,6 +197,10 @@ static inline void blocking_region_end(rb_thread_t *th, struct rb_blocking_regio
     if (blocking_region_begin(th, &__region, (ubf), (ubfarg), fail_if_interrupted) || \
         /* always return true unless fail_if_interrupted */ \
         !only_if_constant(fail_if_interrupted, TRUE)) { \
+        /* Important that this is inlined into the macro, and not part of \
+         * blocking_region_begin - see bug #20493 */ \
+        RB_VM_SAVE_MACHINE_CONTEXT(th); \
+        thread_sched_to_waiting(TH_SCHED(th), th); \
         exec; \
         blocking_region_end(th, &__region); \
     }; \
@@ -1482,9 +1486,6 @@ blocking_region_begin(rb_thread_t *th, struct rb_blocking_region_buffer *region,
         rb_ractor_blocking_threads_inc(th->ractor, __FILE__, __LINE__);
 
         RUBY_DEBUG_LOG("thread_id:%p", (void *)th->nt->thread_id);
-
-        RB_VM_SAVE_MACHINE_CONTEXT(th);
-        thread_sched_to_waiting(TH_SCHED(th), th);
         return TRUE;
     }
     else {
@@ -1893,6 +1894,8 @@ rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
     /* leave from Ruby world: You can not access Ruby values, etc. */
     int released = blocking_region_begin(th, brb, prev_unblock.func, prev_unblock.arg, FALSE);
     RUBY_ASSERT_ALWAYS(released);
+    RB_VM_SAVE_MACHINE_CONTEXT(th);
+    thread_sched_to_waiting(TH_SCHED(th), th);
     return r;
 }
 

From b47533f67b5c4c758b05cdce0fcd0f978fbfe8b9 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 19 May 2024 20:44:02 +0900
Subject: [PATCH 088/242] Remove `rb_bug` after COMPILE_ERROR

Fix test failures since 7afc16aa48beb093b06eb978bc430f90dd771690.
Why crash after reported compile error properly.
---
 prism_compile.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/prism_compile.c b/prism_compile.c
index 44ac70d2fa276c..05dab99dc21ca0 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -5406,7 +5406,6 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             }
 
             COMPILE_ERROR(ERROR_ARGS "Invalid break");
-            rb_bug("Invalid break");
         }
         return;
       }

From 8c0b57d3ee68caea093cb73b5f014a303f37bbb4 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 19 May 2024 20:22:20 +0900
Subject: [PATCH 089/242] `rb_enc_compile_warn` and `rb_enc_compile_warning`
 are printf format

---
 internal/error.h | 2 ++
 prism_compile.c  | 3 ---
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/internal/error.h b/internal/error.h
index 7e41f134d7c78c..7a4daca6b36bfd 100644
--- a/internal/error.h
+++ b/internal/error.h
@@ -142,6 +142,8 @@ VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*,
 PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
+PRINTF_ARGS(void rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
+PRINTF_ARGS(void rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
 rb_warning_category_t rb_warning_category_from_name(VALUE category);
 bool rb_warning_category_enabled_p(rb_warning_category_t category);
 VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
diff --git a/prism_compile.c b/prism_compile.c
index 05dab99dc21ca0..675b4cf86a3122 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -9280,9 +9280,6 @@ pm_parse_process_error(const pm_parse_result_t *result)
     return error;
 }
 
-void rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...);
-void rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...);
-
 /**
  * Parse the parse result and raise a Ruby error if there are any syntax errors.
  * It returns an error if one should be raised. It is assumed that the parse

From cb43540d536e378bcac388c730dfdebb404989e7 Mon Sep 17 00:00:00 2001
From: TOMITA Masahiro <tommy@tmtm.org>
Date: Sun, 19 May 2024 18:21:51 +0900
Subject: [PATCH 090/242] Fix IO::Buffer comment

---
 io_buffer.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/io_buffer.c b/io_buffer.c
index af884f14739a41..5210d4732b6e21 100644
--- a/io_buffer.c
+++ b/io_buffer.c
@@ -2441,13 +2441,13 @@ rb_io_buffer_initialize_copy(VALUE self, VALUE source)
  *
  *  #copy can be used to put buffer into strings associated with buffer:
  *
- *    string= "buffer:    "
- *    # => "buffer:    "
+ *    string= "data:    "
+ *    # => "data:    "
  *    buffer = IO::Buffer.for(string)
  *    buffer.copy(IO::Buffer.for("test"), 5)
  *    # => 4
  *    string
- *    # => "buffer:test"
+ *    # => "data:test"
  *
  *  Attempt to copy into a read-only buffer will fail:
  *
@@ -3571,7 +3571,7 @@ io_buffer_not_inplace(VALUE self)
  *
  *  \Buffer from string:
  *
- *    string = 'buffer'
+ *    string = 'data'
  *    buffer = IO::Buffer.for(string)
  *    # =>
  *    # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
@@ -3579,7 +3579,7 @@ io_buffer_not_inplace(VALUE self)
  *    buffer
  *    # =>
  *    # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
- *    # 0x00000000  64 61 74 61                                     buffer
+ *    # 0x00000000  64 61 74 61                                     data
  *
  *    buffer.get_string(2)  # read content starting from offset 2
  *    # => "ta"
@@ -3594,7 +3594,7 @@ io_buffer_not_inplace(VALUE self)
  *
  *  \Buffer from file:
  *
- *    File.write('test.txt', 'test buffer')
+ *    File.write('test.txt', 'test data')
  *    # => 9
  *    buffer = IO::Buffer.map(File.open('test.txt'))
  *    # =>
@@ -3611,7 +3611,7 @@ io_buffer_not_inplace(VALUE self)
  *    buffer.set_string('---', 1)
  *    # => 3 -- bytes written
  *    File.read('test.txt')
- *    # => "t--- buffer"
+ *    # => "t--- data"
  *
  *  <b>The class is experimental and the interface is subject to change, this
  *  is especially true of file mappings which may be removed entirely in

From 48ebd77e595d569b225151ef281aae537d95d6f5 Mon Sep 17 00:00:00 2001
From: TOMITA Masahiro <tommy@tmtm.org>
Date: Sun, 19 May 2024 20:21:15 +0900
Subject: [PATCH 091/242] Fix comment: Buffer.for(string) without block returns
 readonly buffer

---
 io_buffer.c | 36 +++++++++++++++++-------------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/io_buffer.c b/io_buffer.c
index 5210d4732b6e21..e6ca61bdae0136 100644
--- a/io_buffer.c
+++ b/io_buffer.c
@@ -3572,25 +3572,23 @@ io_buffer_not_inplace(VALUE self)
  *  \Buffer from string:
  *
  *    string = 'data'
- *    buffer = IO::Buffer.for(string)
- *    # =>
- *    # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
- *    # ...
- *    buffer
- *    # =>
- *    # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
- *    # 0x00000000  64 61 74 61                                     data
- *
- *    buffer.get_string(2)  # read content starting from offset 2
- *    # => "ta"
- *    buffer.set_string('---', 1) # write content, starting from offset 1
- *    # => 3
- *    buffer
- *    # =>
- *    # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
- *    # 0x00000000  64 2d 2d 2d                                     d---
- *    string  # original string changed, too
- *    # => "d---"
+ *    IO::Buffer.for(string) do |buffer|
+ *      buffer
+ *      # =>
+ *      # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
+ *      # 0x00000000  64 61 74 61                                     data
+ *
+ *      buffer.get_string(2)  # read content starting from offset 2
+ *      # => "ta"
+ *      buffer.set_string('---', 1) # write content, starting from offset 1
+ *      # => 3
+ *      buffer
+ *      # =>
+ *      # #<IO::Buffer 0x00007f3f02be9b18+4 SLICE>
+ *      # 0x00000000  64 2d 2d 2d                                     d---
+ *      string  # original string changed, too
+ *      # => "d---"
+ *    end
  *
  *  \Buffer from file:
  *

From d037c5196a14c03e72746ccdf0437b5dd4f80a69 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Mon, 20 May 2024 01:30:49 +0900
Subject: [PATCH 092/242] Suppress -Wclobbered warnings

At 7afc16aa48beb093b06eb978bc430f90dd771690, now `BLOCKING_REGION`
contains `setjmp` call in `RB_VM_SAVE_MACHINE_CONTEXT`.  By this
change, variables in blocks for this macro may be clobbered.
---
 thread.c | 54 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 33 insertions(+), 21 deletions(-)

diff --git a/thread.c b/thread.c
index 80537fd41dfee9..25e4cf1b748791 100644
--- a/thread.c
+++ b/thread.c
@@ -1768,7 +1768,7 @@ rb_thread_mn_schedulable(VALUE thval)
 VALUE
 rb_thread_io_blocking_call(rb_blocking_function_t *func, void *data1, int fd, int events)
 {
-    rb_execution_context_t * volatile ec = GET_EC();
+    rb_execution_context_t *volatile ec = GET_EC();
     rb_thread_t *th = rb_ec_thread_ptr(ec);
 
     RUBY_DEBUG_LOG("th:%u fd:%d ev:%d", rb_th_serial(th), fd, events);
@@ -1796,6 +1796,7 @@ rb_thread_io_blocking_call(rb_blocking_function_t *func, void *data1, int fd, in
                 saved_errno = errno;
             }, ubf_select, waiting_fd.th, FALSE);
 
+            th = rb_ec_thread_ptr(ec);
             if (events &&
                 blocking_call_retryable_p((int)val, saved_errno) &&
                 thread_io_wait_events(th, fd, events, NULL)) {
@@ -1805,6 +1806,7 @@ rb_thread_io_blocking_call(rb_blocking_function_t *func, void *data1, int fd, in
         }
         EC_POP_TAG();
 
+        th = rb_ec_thread_ptr(ec);
         th->mn_schedulable = prev_mn_schedulable;
     }
     /*
@@ -4208,9 +4210,10 @@ rb_fd_set(int fd, rb_fdset_t *set)
 #endif
 
 static int
-wait_retryable(int *result, int errnum, rb_hrtime_t *rel, rb_hrtime_t end)
+wait_retryable(volatile int *result, int errnum, rb_hrtime_t *rel, rb_hrtime_t end)
 {
-    if (*result < 0) {
+    int r = *result;
+    if (r < 0) {
         switch (errnum) {
           case EINTR:
 #ifdef ERESTART
@@ -4224,7 +4227,7 @@ wait_retryable(int *result, int errnum, rb_hrtime_t *rel, rb_hrtime_t end)
         }
         return FALSE;
     }
-    else if (*result == 0) {
+    else if (r == 0) {
         /* check for spurious wakeup */
         if (rel) {
             return !hrtime_update_expire(rel, end);
@@ -4262,11 +4265,12 @@ static VALUE
 do_select(VALUE p)
 {
     struct select_set *set = (struct select_set *)p;
-    int result = 0;
+    volatile int result = 0;
     int lerrno;
     rb_hrtime_t *to, rel, end = 0;
 
     timeout_prepare(&to, &rel, &end, set->timeout);
+    volatile rb_hrtime_t endtime = end;
 #define restore_fdset(dst, src) \
     ((dst) ? rb_fd_dup(dst, src) : (void)0)
 #define do_select_update() \
@@ -4282,15 +4286,15 @@ do_select(VALUE p)
             struct timeval tv;
 
             if (!RUBY_VM_INTERRUPTED(set->th->ec)) {
-               result = native_fd_select(set->max,
-                                         set->rset, set->wset, set->eset,
-                                         rb_hrtime2timeval(&tv, to), set->th);
+                result = native_fd_select(set->max,
+                                          set->rset, set->wset, set->eset,
+                                          rb_hrtime2timeval(&tv, to), set->th);
                 if (result < 0) lerrno = errno;
             }
         }, ubf_select, set->th, TRUE);
 
         RUBY_VM_CHECK_INTS_BLOCKING(set->th->ec); /* may raise */
-    } while (wait_retryable(&result, lerrno, to, end) && do_select_update());
+    } while (wait_retryable(&result, lerrno, to, endtime) && do_select_update());
 
     if (result < 0) {
         errno = lerrno;
@@ -4352,6 +4356,23 @@ rb_thread_fd_select(int max, rb_fdset_t * read, rb_fdset_t * write, rb_fdset_t *
 #  define POLLERR_SET (0)
 #endif
 
+static int
+wait_for_single_fd_blocking_region(rb_thread_t *th, struct pollfd *fds, nfds_t nfds,
+                                   rb_hrtime_t *const to, volatile int *lerrno)
+{
+    struct timespec ts;
+    volatile int result = 0;
+
+    *lerrno = 0;
+    BLOCKING_REGION(th, {
+        if (!RUBY_VM_INTERRUPTED(th->ec)) {
+            result = ppoll(fds, nfds, rb_hrtime2timespec(&ts, to), 0);
+            if (result < 0) *lerrno = errno;
+        }
+    }, ubf_select, th, TRUE);
+    return result;
+}
+
 /*
  * returns a mask of events
  */
@@ -4363,7 +4384,7 @@ rb_thread_wait_for_single_fd(int fd, int events, struct timeval *timeout)
         .events = (short)events,
         .revents = 0,
     }};
-    int result = 0;
+    volatile int result = 0;
     nfds_t nfds;
     struct waiting_fd wfd;
     enum ruby_tag_type state;
@@ -4387,17 +4408,8 @@ rb_thread_wait_for_single_fd(int fd, int events, struct timeval *timeout)
             RUBY_VM_CHECK_INTS_BLOCKING(wfd.th->ec);
             timeout_prepare(&to, &rel, &end, timeout);
             do {
-                nfds = 1;
-
-                lerrno = 0;
-                BLOCKING_REGION(wfd.th, {
-                    struct timespec ts;
-
-                    if (!RUBY_VM_INTERRUPTED(wfd.th->ec)) {
-                        result = ppoll(fds, nfds, rb_hrtime2timespec(&ts, to), 0);
-                        if (result < 0) lerrno = errno;
-                    }
-                }, ubf_select, wfd.th, TRUE);
+                nfds = numberof(fds);
+                result = wait_for_single_fd_blocking_region(wfd.th, fds, nfds, to, &lerrno);
 
                 RUBY_VM_CHECK_INTS_BLOCKING(wfd.th->ec);
             } while (wait_retryable(&result, lerrno, to, end));

From a10a483af9786702152670e85b198dfc9156aea5 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sat, 18 May 2024 15:34:49 +0900
Subject: [PATCH 093/242] [rubygems/rubygems] Should rescue vendored net-http
 exception

https://github.com/rubygems/rubygems/commit/7d2c4cf364
---
 test/rubygems/test_bundled_ca.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/rubygems/test_bundled_ca.rb b/test/rubygems/test_bundled_ca.rb
index 50e621f22b490b..a737185681ee25 100644
--- a/test/rubygems/test_bundled_ca.rb
+++ b/test/rubygems/test_bundled_ca.rb
@@ -33,7 +33,7 @@ def assert_https(host)
     http.verify_mode = OpenSSL::SSL::VERIFY_PEER
     http.cert_store = bundled_certificate_store
     http.get("/")
-  rescue Errno::ENOENT, Errno::ETIMEDOUT, SocketError, Net::OpenTimeout
+  rescue Errno::ENOENT, Errno::ETIMEDOUT, SocketError, Gem::Net::OpenTimeout
     pend "#{host} seems offline, I can't tell whether ssl would work."
   rescue OpenSSL::SSL::SSLError => e
     # Only fail for certificate verification errors

From eb410c9fde271886709873fe0eff3bb2e621eb2b Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Mon, 20 May 2024 12:44:28 +0900
Subject: [PATCH 094/242] [ruby/error_highlight] Load "did_you_mean" explicitly
 in test

I'm not sure how it works, but I seem to get an error
`undefined method 'formatter' for module DidYouMean` in parallel mode of
`make test-all`.

https://app.launchableinc.com/organizations/ruby/workspaces/ruby/data/test-paths/file%3Dtest%2Ferror_highlight%2Ftest_error_highlight.rb%23class%3DErrorHighlightTest%23testcase%3Dtest_explicit_raise_name_error?organizationId=ruby&workspaceId=ruby&testPathId=file%3Dtest%2Ferror_highlight%2Ftest_error_highlight.rb%23class%3DErrorHighlightTest%23testcase%3Dtest_explicit_raise_name_error&testSessionStatus=flake

https://github.com/ruby/error_highlight/commit/f931b42430
---
 test/error_highlight/test_error_highlight.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/error_highlight/test_error_highlight.rb b/test/error_highlight/test_error_highlight.rb
index 2095970af17968..69aef313391bc7 100644
--- a/test/error_highlight/test_error_highlight.rb
+++ b/test/error_highlight/test_error_highlight.rb
@@ -1,6 +1,7 @@
 require "test/unit"
 
 require "error_highlight"
+require "did_you_mean"
 require "tempfile"
 
 class ErrorHighlightTest < Test::Unit::TestCase

From 18eaf0be905e3e251423b42d6f4e56b7cae1bc3b Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Mon, 20 May 2024 11:44:27 +0900
Subject: [PATCH 095/242] [Bug #20494] Search non-default directories for GMP

Co-Authored-by: lish82 (Hiroki Katagiri)
---
 configure.ac                 | 3 ++-
 tool/m4/ruby_check_header.m4 | 8 ++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 tool/m4/ruby_check_header.m4

diff --git a/configure.ac b/configure.ac
index e9a452ebee2326..09f95b2beceb91 100644
--- a/configure.ac
+++ b/configure.ac
@@ -16,6 +16,7 @@ m4_include([tool/m4/ruby_append_option.m4])dnl
 m4_include([tool/m4/ruby_append_options.m4])dnl
 m4_include([tool/m4/ruby_check_builtin_func.m4])dnl
 m4_include([tool/m4/ruby_check_builtin_setjmp.m4])dnl
+m4_include([tool/m4/ruby_check_header.m4])dnl
 m4_include([tool/m4/ruby_check_printf_prefix.m4])dnl
 m4_include([tool/m4/ruby_check_setjmp.m4])dnl
 m4_include([tool/m4/ruby_check_signedness.m4])dnl
@@ -1375,7 +1376,7 @@ AS_CASE("$target_cpu", [x64|x86_64|i[3-6]86*], [
 RUBY_UNIVERSAL_CHECK_HEADER([x86_64, i386], x86intrin.h)
 
 AS_IF([test "x$with_gmp" != xno],
-  [AC_CHECK_HEADERS(gmp.h)
+  [RUBY_CHECK_HEADER(gmp.h)
    AS_IF([test "x$ac_cv_header_gmp_h" != xno],
      AC_SEARCH_LIBS([__gmpz_init], [gmp],
        [AC_DEFINE(HAVE_LIBGMP, 1)]))])
diff --git a/tool/m4/ruby_check_header.m4 b/tool/m4/ruby_check_header.m4
new file mode 100644
index 00000000000000..171455549e3362
--- /dev/null
+++ b/tool/m4/ruby_check_header.m4
@@ -0,0 +1,8 @@
+dnl -*- Autoconf -*-
+AC_DEFUN([RUBY_CHECK_HEADER],
+    [# RUBY_CHECK_HEADER($@)
+    save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS m4_if([$5], [], [$INCFLAGS], [$5])"
+    AC_CHECK_HEADER([$1], [$2], [$3], [$4])
+    CPPFLAGS="$save_CPPFLAGS"
+    unset save_CPPFLAGS])

From 14da90f26294b0ccba872b433dbb726544f486f7 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Mon, 20 May 2024 12:56:33 +0900
Subject: [PATCH 096/242] --with-gmp-dir option is for ruby itself, not
 extensions

---
 .github/actions/setup/macos/action.yml | 6 +++++-
 .github/workflows/macos.yml            | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/.github/actions/setup/macos/action.yml b/.github/actions/setup/macos/action.yml
index 896930de84d161..b96e959aa69147 100644
--- a/.github/actions/setup/macos/action.yml
+++ b/.github/actions/setup/macos/action.yml
@@ -18,7 +18,11 @@ runs:
     - name: Set ENV
       shell: bash
       run: |
-        for lib in openssl@1.1 gmp; do
+        for lib in gmp; do
+          ruby_configure_args="${ruby_configure_args:+$ruby_configure_args }--with-${lib%@*}-dir=$(brew --prefix $lib)"
+        done
+        for lib in openssl@1.1; do
           CONFIGURE_ARGS="${CONFIGURE_ARGS:+$CONFIGURE_ARGS }--with-${lib%@*}-dir=$(brew --prefix $lib)"
         done
+        echo ruby_configure_args="${ruby_configure_args}" >> $GITHUB_ENV
         echo CONFIGURE_ARGS="${CONFIGURE_ARGS}" >> $GITHUB_ENV
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index e71706b186070d..cc4e66cf16e1c1 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -71,7 +71,7 @@ jobs:
           fetch-depth: 10
 
       - name: Run configure
-        run: ../src/configure -C --disable-install-doc
+        run: ../src/configure -C --disable-install-doc ${ruby_configure_args}
 
       - run: make prepare-gems
         if: ${{ matrix.test_task == 'test-bundled-gems' }}

From fa26ef5bf715c7eb0bd80dd587a3f86f808f56af Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Mon, 20 May 2024 12:58:56 +0900
Subject: [PATCH 097/242] Fix the end of "compiler section"

---
 configure.ac | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index 09f95b2beceb91..d787bc3502eb71 100644
--- a/configure.ac
+++ b/configure.ac
@@ -989,7 +989,6 @@ AC_SUBST(incflags, "$INCFLAGS")
 
 test -z "${ac_env_CFLAGS_set}" -a -n "${cflags+set}" && eval CFLAGS="\"$cflags $ARCH_FLAG\""
 test -z "${ac_env_CXXFLAGS_set}" -a -n "${cxxflags+set}" && eval CXXFLAGS="\"$cxxflags $ARCH_FLAG\""
-}
 
 AC_CACHE_CHECK([whether compiler has statement and declarations in expressions],
   rb_cv_have_stmt_and_decl_in_expr,
@@ -999,6 +998,7 @@ AC_CACHE_CHECK([whether compiler has statement and declarations in expressions],
 AS_IF([test "$rb_cv_have_stmt_and_decl_in_expr" = yes], [
   AC_DEFINE(HAVE_STMT_AND_DECL_IN_EXPR)
 ])
+}
 
 [begin]_group "header and library section" && {
 AC_ARG_WITH(winnt-ver,

From 0b38403328f02f2b103e15103b2ace69d123c9f3 Mon Sep 17 00:00:00 2001
From: Jean Boussier <jean.boussier@gmail.com>
Date: Mon, 20 May 2024 11:42:34 +0900
Subject: [PATCH 098/242] Fix incorrect assertion in TestThreadInstrumentation

The test meant to assert the thread is suspended at least once,
but was actually asserting to it to be suspected at least twice.
---
 test/-ext-/thread/test_instrumentation_api.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/-ext-/thread/test_instrumentation_api.rb b/test/-ext-/thread/test_instrumentation_api.rb
index 9a3b67fa108512..663e41be537f22 100644
--- a/test/-ext-/thread/test_instrumentation_api.rb
+++ b/test/-ext-/thread/test_instrumentation_api.rb
@@ -54,7 +54,7 @@ def test_thread_pass_multi_thread
     thread&.join
   end
 
-  def test_muti_thread_timeline
+  def test_multi_thread_timeline
     threads = nil
     full_timeline = record do
       threads = threaded_cpu_bound_work(1.0)
@@ -68,7 +68,7 @@ def test_muti_thread_timeline
     threads.each do |thread|
       timeline = timeline_for(thread, full_timeline)
       assert_consistent_timeline(timeline)
-      assert timeline.count(:suspended) > 1, "Expected threads to yield suspended at least once: #{timeline.inspect}"
+      assert_operator timeline.count(:suspended), :>=, 1, "Expected threads to yield suspended at least once: #{timeline.inspect}"
     end
 
     timeline = timeline_for(Thread.current, full_timeline)

From 70ad58cb62b195ba86a5ef07a565b22b02a040ea Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Mon, 20 May 2024 17:09:41 +0900
Subject: [PATCH 099/242] Update bundled_gems

---
 gems/bundled_gems | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gems/bundled_gems b/gems/bundled_gems
index bb6dcb5447b992..1ff6fbc314f024 100644
--- a/gems/bundled_gems
+++ b/gems/bundled_gems
@@ -10,7 +10,7 @@ minitest        5.23.0  https://github.com/minitest/minitest
 power_assert    2.0.3   https://github.com/ruby/power_assert 84e85124c5014a139af39161d484156cfe87a9ed
 rake            13.2.1  https://github.com/ruby/rake
 test-unit       3.6.2   https://github.com/test-unit/test-unit
-rexml           3.2.6   https://github.com/ruby/rexml
+rexml           3.2.8   https://github.com/ruby/rexml
 rss             0.3.0   https://github.com/ruby/rss
 net-ftp         0.3.4   https://github.com/ruby/net-ftp
 net-imap        0.4.11  https://github.com/ruby/net-imap
@@ -21,7 +21,7 @@ prime           0.1.2   https://github.com/ruby/prime
 rbs             3.4.4   https://github.com/ruby/rbs ba7872795d5de04adb8ff500c0e6afdc81a041dd
 typeprof        0.21.11 https://github.com/ruby/typeprof b19a6416da3a05d57fadd6ffdadb382b6d236ca5
 debug           1.9.2   https://github.com/ruby/debug
-racc            1.7.3   https://github.com/ruby/racc
+racc            1.8.0   https://github.com/ruby/racc
 mutex_m         0.2.0   https://github.com/ruby/mutex_m
 getoptlong      0.2.1   https://github.com/ruby/getoptlong
 base64          0.2.0   https://github.com/ruby/base64

From 7f0e26b7f99bf76408569892ce20318501f74729 Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Mon, 20 May 2024 17:10:26 +0900
Subject: [PATCH 100/242] Re-use strscan with ruby repo

---
 tool/lib/bundled_gem.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tool/lib/bundled_gem.rb b/tool/lib/bundled_gem.rb
index 3ba27f6d645e67..8730f0fb3ac535 100644
--- a/tool/lib/bundled_gem.rb
+++ b/tool/lib/bundled_gem.rb
@@ -11,7 +11,8 @@ module BundledGem
     "time", # net-ftp
     "singleton", # prime
     "ipaddr", # rinda
-    "forwardable" # prime, rinda
+    "forwardable", # prime, rinda
+    "strscan" # rexml
   ]
 
   module_function

From 8248268434db7523093b2ac55ebf0e03e102ada9 Mon Sep 17 00:00:00 2001
From: git <svn-admin@ruby-lang.org>
Date: Mon, 20 May 2024 09:10:55 +0000
Subject: [PATCH 101/242] Update bundled gems list at
 7f0e26b7f99bf76408569892ce2031 [ci skip]

---
 NEWS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NEWS.md b/NEWS.md
index 5972eac924ca40..558da7ebb50beb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -68,6 +68,7 @@ The following bundled gems are updated.
 * rbs 3.4.4
 * typeprof 0.21.11
 * debug 1.9.2
+* racc 1.8.0
 
 The following bundled gems are promoted from default gems.
 

From e90e8f8bd35391233f43d196d23b46ba8c20d56e Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 09:54:14 -0400
Subject: [PATCH 102/242] [ruby/prism] Implement ambiguous binary operator
 warning

https://github.com/ruby/prism/commit/6258c3695f
---
 prism/config.yml                     |  1 +
 prism/prism.c                        | 36 +++++++++++++++++++++++++++-
 prism/templates/src/diagnostic.c.erb |  1 +
 test/prism/newline_test.rb           |  1 +
 test/prism/warnings_test.rb          | 17 +++++++++++++
 5 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/prism/config.yml b/prism/config.yml
index 0652cc4a9fa2bf..6b4b1aa9c0e1dc 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -274,6 +274,7 @@ errors:
   - WRITE_TARGET_UNEXPECTED
   - XSTRING_TERM
 warnings:
+  - AMBIGUOUS_BINARY_OPERATOR
   - AMBIGUOUS_FIRST_ARGUMENT_MINUS
   - AMBIGUOUS_FIRST_ARGUMENT_PLUS
   - AMBIGUOUS_PREFIX_AMPERSAND
diff --git a/prism/prism.c b/prism/prism.c
index 02c208808988e9..b1d584d0ab9356 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -423,10 +423,18 @@ lex_mode_pop(pm_parser_t *parser) {
  * This is the equivalent of IS_lex_state is CRuby.
  */
 static inline bool
-lex_state_p(pm_parser_t *parser, pm_lex_state_t state) {
+lex_state_p(const pm_parser_t *parser, pm_lex_state_t state) {
     return parser->lex_state & state;
 }
 
+/**
+ * This is equivalent to the predicate of warn_balanced in CRuby.
+ */
+static inline bool
+ambiguous_operator_p(const pm_parser_t *parser, bool space_seen) {
+    return !lex_state_p(parser, PM_LEX_STATE_CLASS | PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME | PM_LEX_STATE_ENDFN) && space_seen && !pm_char_is_whitespace(*parser->current.end);
+}
+
 typedef enum {
     PM_IGNORED_NEWLINE_NONE = 0,
     PM_IGNORED_NEWLINE_ALL,
@@ -10821,6 +10829,8 @@ parser_lex(pm_parser_t *parser) {
                             type = PM_TOKEN_USTAR_STAR;
                         } else if (lex_state_beg_p(parser)) {
                             type = PM_TOKEN_USTAR_STAR;
+                        } else if (ambiguous_operator_p(parser, space_seen)) {
+                            PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "**", "argument prefix");
                         }
 
                         if (lex_state_operator_p(parser)) {
@@ -10844,6 +10854,8 @@ parser_lex(pm_parser_t *parser) {
                         type = PM_TOKEN_USTAR;
                     } else if (lex_state_beg_p(parser)) {
                         type = PM_TOKEN_USTAR;
+                    } else if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "*", "argument prefix");
                     }
 
                     if (lex_state_operator_p(parser)) {
@@ -11017,6 +11029,10 @@ parser_lex(pm_parser_t *parser) {
                             LEX(PM_TOKEN_LESS_LESS_EQUAL);
                         }
 
+                        if (ambiguous_operator_p(parser, space_seen)) {
+                            PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "<<", "here document");
+                        }
+
                         if (lex_state_operator_p(parser)) {
                             lex_state_set(parser, PM_LEX_STATE_ARG);
                         } else {
@@ -11130,6 +11146,8 @@ parser_lex(pm_parser_t *parser) {
                         type = PM_TOKEN_UAMPERSAND;
                     } else if (lex_state_beg_p(parser)) {
                         type = PM_TOKEN_UAMPERSAND;
+                    } else if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "&", "argument prefix");
                     }
 
                     if (lex_state_operator_p(parser)) {
@@ -11204,6 +11222,10 @@ parser_lex(pm_parser_t *parser) {
                         LEX(PM_TOKEN_UPLUS);
                     }
 
+                    if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "+", "unary operator");
+                    }
+
                     lex_state_set(parser, PM_LEX_STATE_BEG);
                     LEX(PM_TOKEN_PLUS);
                 }
@@ -11241,6 +11263,10 @@ parser_lex(pm_parser_t *parser) {
                         LEX(pm_char_is_decimal_digit(peek(parser)) ? PM_TOKEN_UMINUS_NUM : PM_TOKEN_UMINUS);
                     }
 
+                    if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "-", "unary operator");
+                    }
+
                     lex_state_set(parser, PM_LEX_STATE_BEG);
                     LEX(PM_TOKEN_MINUS);
                 }
@@ -11339,6 +11365,10 @@ parser_lex(pm_parser_t *parser) {
                         LEX(PM_TOKEN_REGEXP_BEGIN);
                     }
 
+                    if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "/", "regexp literal");
+                    }
+
                     if (lex_state_operator_p(parser)) {
                         lex_state_set(parser, PM_LEX_STATE_ARG);
                     } else {
@@ -11520,6 +11550,10 @@ parser_lex(pm_parser_t *parser) {
                         }
                     }
 
+                    if (ambiguous_operator_p(parser, space_seen)) {
+                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "%", "string literal");
+                    }
+
                     lex_state_set(parser, lex_state_operator_p(parser) ? PM_LEX_STATE_ARG : PM_LEX_STATE_BEG);
                     LEX(PM_TOKEN_PERCENT);
                 }
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index d9e195e08f3f0e..57c52602f42689 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -356,6 +356,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_XSTRING_TERM]                       = { "expected a closing delimiter for the `%x` or backtick string", PM_ERROR_LEVEL_SYNTAX },
 
     // Warnings
+    [PM_WARN_AMBIGUOUS_BINARY_OPERATOR]         = { "'%s' after local variable or literal is interpreted as binary operator even though it seems like %s", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS]    = { "ambiguous first argument; put parentheses or a space even after `-` operator", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS]     = { "ambiguous first argument; put parentheses or a space even after `+` operator", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND]        = { "ambiguous `&` has been interpreted as an argument prefix", PM_WARNING_LEVEL_VERBOSE },
diff --git a/test/prism/newline_test.rb b/test/prism/newline_test.rb
index f7511f665cdfea..96374ce6a70283 100644
--- a/test/prism/newline_test.rb
+++ b/test/prism/newline_test.rb
@@ -15,6 +15,7 @@ class NewlineTest < TestCase
       regexp_test.rb
       static_literals_test.rb
       unescape_test.rb
+      warnings_test.rb
     ]
 
     filepaths.each do |relative|
diff --git a/test/prism/warnings_test.rb b/test/prism/warnings_test.rb
index b138a3cb431921..3e26cd2227ded4 100644
--- a/test/prism/warnings_test.rb
+++ b/test/prism/warnings_test.rb
@@ -23,6 +23,23 @@ def test_ambiguous_regexp
       assert_warning("a /b/", "wrap regexp in parentheses")
     end
 
+    def test_binary_operator
+      [
+        [:**, "argument prefix"],
+        [:*, "argument prefix"],
+        [:<<, "here document"],
+        [:&, "argument prefix"],
+        [:+, "unary operator"],
+        [:-, "unary operator"],
+        [:/, "regexp literal"],
+        [:%, "string literal"]
+      ].each do |(operator, warning)|
+        assert_warning("puts 1 #{operator}0", warning)
+        assert_warning("puts :a #{operator}0", warning)
+        assert_warning("m = 1; puts m #{operator}0", warning)
+      end
+    end
+
     def test_equal_in_conditional
       assert_warning("if a = 1; end; a = a", "should be ==")
     end

From 2e8ae139748f137a1585b5f464e505ac479a1332 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 10:42:52 -0400
Subject: [PATCH 103/242] [ruby/prism] Fix invalid read at EOF

https://github.com/ruby/prism/commit/dddaf67c34
---
 prism/prism.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index b1d584d0ab9356..22c19f56b57519 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -427,14 +427,6 @@ lex_state_p(const pm_parser_t *parser, pm_lex_state_t state) {
     return parser->lex_state & state;
 }
 
-/**
- * This is equivalent to the predicate of warn_balanced in CRuby.
- */
-static inline bool
-ambiguous_operator_p(const pm_parser_t *parser, bool space_seen) {
-    return !lex_state_p(parser, PM_LEX_STATE_CLASS | PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME | PM_LEX_STATE_ENDFN) && space_seen && !pm_char_is_whitespace(*parser->current.end);
-}
-
 typedef enum {
     PM_IGNORED_NEWLINE_NONE = 0,
     PM_IGNORED_NEWLINE_ALL,
@@ -8074,7 +8066,7 @@ pm_do_loop_stack_p(pm_parser_t *parser) {
  * is beyond the end of the source then return '\0'.
  */
 static inline uint8_t
-peek_at(pm_parser_t *parser, const uint8_t *cursor) {
+peek_at(const pm_parser_t *parser, const uint8_t *cursor) {
     if (cursor < parser->end) {
         return *cursor;
     } else {
@@ -8097,7 +8089,7 @@ peek_offset(pm_parser_t *parser, ptrdiff_t offset) {
  * that position is beyond the end of the source then return '\0'.
  */
 static inline uint8_t
-peek(pm_parser_t *parser) {
+peek(const pm_parser_t *parser) {
     return peek_at(parser, parser->current.end);
 }
 
@@ -8162,6 +8154,14 @@ next_newline(const uint8_t *cursor, ptrdiff_t length) {
     return memchr(cursor, '\n', (size_t) length);
 }
 
+/**
+ * This is equivalent to the predicate of warn_balanced in CRuby.
+ */
+static inline bool
+ambiguous_operator_p(const pm_parser_t *parser, bool space_seen) {
+    return !lex_state_p(parser, PM_LEX_STATE_CLASS | PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME | PM_LEX_STATE_ENDFN) && space_seen && !pm_char_is_whitespace(peek(parser));
+}
+
 /**
  * Here we're going to check if this is a "magic" comment, and perform whatever
  * actions are necessary for it here.

From 785fba3b161bc0a54e2fc9c5447526499ef93a74 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 10:00:53 -0400
Subject: [PATCH 104/242] [PRISM] Enable TestSyntax#test_warn_balanced

---
 test/ruby/test_syntax.rb | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index 56b97789e531ac..2f311c859ee862 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -506,10 +506,6 @@ def test_warn_unreachable
   end
 
   def test_warn_balanced
-    warning = <<WARN
-test:1: warning: '%s' after local variable or literal is interpreted as binary operator
-test:1: warning: even though it seems like %s
-WARN
     [
      [:**, "argument prefix"],
      [:*, "argument prefix"],
@@ -523,7 +519,9 @@ def test_warn_balanced
       all_assertions do |a|
         ["puts 1 #{op}0", "puts :a #{op}0", "m = 1; puts m #{op}0"].each do |src|
           a.for(src) do
-            assert_warning(warning % [op, syn], src) do
+            warning = /'#{Regexp.escape(op)}' after local variable or literal is interpreted as binary operator.+?even though it seems like #{syn}/m
+
+            assert_warning(warning, src) do
               assert_valid_syntax(src, "test", verbose: true)
             end
           end

From f1bbcc81261aeeb304d0d0b52d7c2310c01089a8 Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Mon, 20 May 2024 15:25:22 +0900
Subject: [PATCH 105/242] Make sure that kern.coredump=1

---
 .github/workflows/macos.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index cc4e66cf16e1c1..f07990b3da4cbf 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -70,6 +70,11 @@ jobs:
           # Set fetch-depth: 0 so that Launchable can receive commits information.
           fetch-depth: 10
 
+      - name: make sure that kern.coredump=1
+        run: |
+          sysctl -n kern.coredump
+          sudo sysctl -w kern.coredump=1
+
       - name: Run configure
         run: ../src/configure -C --disable-install-doc ${ruby_configure_args}
 

From 1ba93c2c4d4fa89f5fda490b6e82caafb0d5abc6 Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Mon, 20 May 2024 14:53:36 +0900
Subject: [PATCH 106/242] Upload cores to AWS S3 (if any)

---
 .github/workflows/macos.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index f07990b3da4cbf..151df8126bec59 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -129,6 +129,36 @@ jobs:
           SLACK_WEBHOOK_URL: ${{ secrets.SIMPLER_ALERTS_URL }} # ruby-lang slack: ruby/simpler-alerts-bot
         if: ${{ failure() }}
 
+      - name: Resolve job ID
+        id: job_id
+        uses: actions/github-script@main
+        env:
+          matrix: ${{ toJson(matrix) }}
+        with:
+          script: |
+            const { data: workflow_run } = await github.rest.actions.listJobsForWorkflowRun({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: context.runId
+            });
+            const matrix = JSON.parse(process.env.matrix);
+            const job_name = `${context.job}${matrix ? ` (${Object.values(matrix).join(", ")})` : ""}`;
+            return workflow_run.jobs.find((job) => job.name === job_name).id;
+
+      - name: upload /cores
+        run: |
+          ls -l /cores
+          CORES_TAR_GZ="cores-${{ github.run_id }}-${{ steps.job_id.outputs.result }}.tar.gz"
+          echo "test: $CORES_TAR_GZ"
+          if [ -n "$(ls /cores)" ]; then
+            tar czf /cores "$CORES_TAR_GZ"
+            aws s3 cp "$CORES_TAR_GZ" "s3://ruby-core-files/$CORES_TAR_GZ"
+          fi
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.RUBY_CORE_FILES_AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.RUBY_CORE_FILES_AWS_SECRET_ACCESS_KEY }}
+          AWS_DEFAULT_REGION: ap-northeast-1
+
   result:
     if: ${{ always() }}
     name: ${{ github.workflow }} result

From ca5b4580442eac3ee8ad3f98b692d204d7b92f03 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 10:44:13 -0400
Subject: [PATCH 107/242] [PRISM] Match CRuby line semantics for evstr

---
 prism/prism.c                        |  7 +++++++
 prism_compile.c                      | 17 +++++++++++------
 test/.excludes-prism/TestCoverage.rb |  1 -
 3 files changed, 18 insertions(+), 7 deletions(-)
 delete mode 100644 test/.excludes-prism/TestCoverage.rb

diff --git a/prism/prism.c b/prism/prism.c
index 22c19f56b57519..bad6c7ff2ba621 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -15460,6 +15460,13 @@ parse_string_part(pm_parser_t *parser) {
             expect1(parser, PM_TOKEN_EMBEXPR_END, PM_ERR_EMBEXPR_END);
             pm_token_t closing = parser->previous;
 
+            // If this set of embedded statements only contains a single
+            // statement, then Ruby does not consider it as a possible statement
+            // that could emit a line event.
+            if (statements != NULL && statements->body.size == 1) {
+                pm_node_flag_unset(statements->body.nodes[0], PM_NODE_FLAG_NEWLINE);
+            }
+
             return (pm_node_t *) pm_embedded_statements_node_create(parser, &opening, statements, &closing);
         }
 
diff --git a/prism_compile.c b/prism_compile.c
index 675b4cf86a3122..c9f2fed9ca6741 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -570,6 +570,7 @@ pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const
 
     if (parts_size > 0) {
         VALUE current_string = Qnil;
+        pm_line_column_t current_location = *node_location;
 
         for (size_t index = 0; index < parts_size; index++) {
             const pm_node_t *part = parts->nodes[index];
@@ -590,6 +591,7 @@ pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const
                 }
                 else {
                     current_string = string_value;
+                    if (index != 0) current_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, part);
                 }
             }
             else {
@@ -616,6 +618,7 @@ pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const
                     }
                     else {
                         current_string = string_value;
+                        current_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, part);
                     }
                 }
                 else {
@@ -640,11 +643,13 @@ pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const
                         current_string = rb_enc_str_new(NULL, 0, encoding);
                     }
 
-                    PUSH_INSN1(ret, *node_location, putobject, rb_fstring(current_string));
+                    PUSH_INSN1(ret, current_location, putobject, rb_fstring(current_string));
                     PM_COMPILE_NOT_POPPED(part);
-                    PUSH_INSN(ret, *node_location, dup);
-                    PUSH_INSN1(ret, *node_location, objtostring, new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE , NULL, FALSE));
-                    PUSH_INSN(ret, *node_location, anytostring);
+
+                    const pm_line_column_t current_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, part);
+                    PUSH_INSN(ret, current_location, dup);
+                    PUSH_INSN1(ret, current_location, objtostring, new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE));
+                    PUSH_INSN(ret, current_location, anytostring);
 
                     current_string = Qnil;
                     stack_size += 2;
@@ -656,10 +661,10 @@ pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const
             current_string = rb_fstring(current_string);
 
             if (stack_size == 0 && interpolated) {
-                PUSH_INSN1(ret, *node_location, putstring, current_string);
+                PUSH_INSN1(ret, current_location, putstring, current_string);
             }
             else {
-                PUSH_INSN1(ret, *node_location, putobject, current_string);
+                PUSH_INSN1(ret, current_location, putobject, current_string);
             }
 
             current_string = Qnil;
diff --git a/test/.excludes-prism/TestCoverage.rb b/test/.excludes-prism/TestCoverage.rb
deleted file mode 100644
index f122d6edbc768f..00000000000000
--- a/test/.excludes-prism/TestCoverage.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_eval, "respect eval coverage setting")

From 78e504f21d3148b7b6fa78ea70d10426170f4112 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 11:36:15 -0400
Subject: [PATCH 108/242] [PRISM] Enable TestPrism#test_truncated_source_line

---
 test/.excludes-prism/TestParse.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
index 513a7ed9429a8f..f0b7118624f506 100644
--- a/test/.excludes-prism/TestParse.rb
+++ b/test/.excludes-prism/TestParse.rb
@@ -1,2 +1 @@
-exclude(:test_truncated_source_line, "truncate error message")
 exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")

From a708b6aa6589b06ed059ad40e7d4e71ebe0e16e3 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 11:29:50 -0400
Subject: [PATCH 109/242] [PRISM] Respect eval coverage setting

---
 iseq.c          | 7 +++++++
 load.c          | 1 +
 prism_compile.c | 4 ++++
 prism_compile.h | 8 +++++---
 ruby.c          | 1 +
 vm_eval.c       | 7 +++++++
 6 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/iseq.c b/iseq.c
index aab58e3760f35e..9631488411c6c7 100644
--- a/iseq.c
+++ b/iseq.c
@@ -1029,8 +1029,13 @@ pm_iseq_new_with_opt(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpa
     ISEQ_BODY(iseq)->prism = true;
     ISEQ_BODY(iseq)->param.flags.use_block = true; // unused block warning is not supported yet
 
+    rb_compile_option_t next_option;
     if (!option) option = &COMPILE_OPTION_DEFAULT;
 
+    next_option = *option;
+    next_option.coverage_enabled = node->coverage_enabled < 0 ? 0 : node->coverage_enabled > 0;
+    option = &next_option;
+
     pm_location_t *location = &node->base.location;
     int32_t start_line = node->parser->start_line;
 
@@ -1273,6 +1278,7 @@ pm_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, V
 
     pm_parse_result_t result = { 0 };
     pm_options_line_set(&result.options, NUM2INT(line));
+    result.node.coverage_enabled = 1;
 
     switch (option.frozen_string_literal) {
       case ISEQ_FROZEN_STRING_LITERAL_UNSET:
@@ -1708,6 +1714,7 @@ iseqw_s_compile_file_prism(int argc, VALUE *argv, VALUE self)
 
     pm_parse_result_t result = { 0 };
     result.options.line = 1;
+    result.node.coverage_enabled = 1;
 
     VALUE error = pm_load_parse_file(&result, file);
 
diff --git a/load.c b/load.c
index 37f7248b7dc263..af2475f999b29e 100644
--- a/load.c
+++ b/load.c
@@ -746,6 +746,7 @@ load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
         if (*rb_ruby_prism_ptr()) {
             pm_parse_result_t result = { 0 };
             result.options.line = 1;
+            result.node.coverage_enabled = 1;
 
             VALUE error = pm_load_parse_file(&result, fname);
 
diff --git a/prism_compile.c b/prism_compile.c
index c9f2fed9ca6741..58c70748e1c37a 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -2868,6 +2868,7 @@ pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_
         scope->encoding = previous->encoding;
         scope->filepath_encoding = previous->filepath_encoding;
         scope->constants = previous->constants;
+        scope->coverage_enabled = previous->coverage_enabled;
     }
 
     switch (PM_NODE_TYPE(node)) {
@@ -9299,6 +9300,7 @@ pm_parse_process(pm_parse_result_t *result, pm_node_t *node)
     // freed regardless of whether or we return an error.
     pm_scope_node_t *scope_node = &result->node;
     rb_encoding *filepath_encoding = scope_node->filepath_encoding;
+    int coverage_enabled = scope_node->coverage_enabled;
 
     pm_scope_node_init(node, scope_node, NULL);
     scope_node->filepath_encoding = filepath_encoding;
@@ -9306,6 +9308,8 @@ pm_parse_process(pm_parse_result_t *result, pm_node_t *node)
     scope_node->encoding = rb_enc_find(parser->encoding->name);
     if (!scope_node->encoding) rb_bug("Encoding not found %s!", parser->encoding->name);
 
+    scope_node->coverage_enabled = coverage_enabled;
+
     // Emit all of the various warnings from the parse.
     const pm_diagnostic_t *warning;
     const char *warning_filepath = (const char *) pm_string_source(&parser->filepath);
diff --git a/prism_compile.h b/prism_compile.h
index 0f82782ec02407..8df82c5c7caa2f 100644
--- a/prism_compile.h
+++ b/prism_compile.h
@@ -36,14 +36,16 @@ typedef struct pm_scope_node {
      */
     rb_encoding *filepath_encoding;
 
-    // The size of the local table
-    // on the iseq which includes
-    // locals and hidden variables
+    // The size of the local table on the iseq which includes locals and hidden
+    // variables.
     int local_table_for_iseq_size;
 
     ID *constants;
     st_table *index_lookup_table;
 
+    // The current coverage setting, passed down through the various scopes.
+    int coverage_enabled;
+
     /**
      * This will only be set on the top-level scope node. It will contain all of
      * the instructions pertaining to BEGIN{} nodes.
diff --git a/ruby.c b/ruby.c
index cd7f9ad4b8c371..a8de48d2a60897 100644
--- a/ruby.c
+++ b/ruby.c
@@ -2155,6 +2155,7 @@ prism_script(ruby_cmdline_options_t *opt, pm_parse_result_t *result)
         pm_options_command_line_set(options, command_line);
 
         prism_opt_init(opt);
+        result->node.coverage_enabled = 0;
         error = pm_parse_string(result, opt->e_script, rb_str_new2("-e"));
     }
     else {
diff --git a/vm_eval.c b/vm_eval.c
index 7eafb2d5f7f1a4..8da3f3c5293e3c 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -1629,6 +1629,10 @@ pm_eval_make_iseq(VALUE src, VALUE fname, int line,
     const rb_iseq_t *const parent = vm_block_iseq(base_block);
     const rb_iseq_t *iseq = parent;
     VALUE name = rb_fstring_lit("<compiled>");
+
+    // Conditionally enable coverage depending on the current mode:
+    int coverage_enabled = ((rb_get_coverage_mode() & COVERAGE_TARGET_EVAL) != 0) ? 1 : 0;
+
     if (!fname) {
         fname = rb_source_location(&line);
     }
@@ -1638,10 +1642,12 @@ pm_eval_make_iseq(VALUE src, VALUE fname, int line,
     }
     else {
         fname = get_eval_default_path();
+        coverage_enabled = 0;
     }
 
     pm_parse_result_t result = { 0 };
     pm_options_line_set(&result.options, line);
+    result.node.coverage_enabled = coverage_enabled;
 
     // Cout scopes, one for each parent iseq, plus one for our local scope
     int scopes_count = 0;
@@ -1703,6 +1709,7 @@ pm_eval_make_iseq(VALUE src, VALUE fname, int line,
         RUBY_ASSERT(parent_scope != NULL);
 
         pm_options_scope_t *options_scope = &result.options.scopes[scopes_count - scopes_index - 1];
+        parent_scope->coverage_enabled = coverage_enabled;
         parent_scope->parser = &result.parser;
         parent_scope->index_lookup_table = st_init_numtable();
 

From 6c07aa364d26c686418843de75234e00a4b9b41d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 11:33:55 -0400
Subject: [PATCH 110/242] [PRISM] Remove old prism spec workflow, just use
 default.mspec now

---
 .github/workflows/prism.yml | 4 ++--
 common.mk                   | 9 ---------
 spec/prism.mspec            | 4 ----
 3 files changed, 2 insertions(+), 15 deletions(-)
 delete mode 100644 spec/prism.mspec

diff --git a/.github/workflows/prism.yml b/.github/workflows/prism.yml
index 78b6469db19a54..63abd09cb8c350 100644
--- a/.github/workflows/prism.yml
+++ b/.github/workflows/prism.yml
@@ -95,9 +95,9 @@ jobs:
           RUBY_TESTOPTS: '-q --tty=no --excludes-dir="../src/test/.excludes-prism" --exclude="error_highlight/test_error_highlight.rb" --exclude="prism/encoding_test.rb"'
           RUN_OPTS: ${{ matrix.run_opts }}
 
-      - name: make test-prism-spec
+      - name: make test-spec
         run: |
-          $SETARCH make -s test-prism-spec SPECOPTS="$SPECOPTS"
+          $SETARCH make -s test-spec SPECOPTS="$SPECOPTS"
         timeout-minutes: 10
         env:
           GNUMAKEFLAGS: ''
diff --git a/common.mk b/common.mk
index 18641efd7ffbbd..65e785c5fb8e3d 100644
--- a/common.mk
+++ b/common.mk
@@ -1018,15 +1018,6 @@ yes-test-spec: yes-test-spec-precheck
 	$(ACTIONS_ENDGROUP)
 no-test-spec:
 
-test-prism-spec: $(TEST_RUNNABLE)-test-prism-spec
-yes-test-prism-spec: yes-test-spec-precheck
-	$(ACTIONS_GROUP)
-	$(gnumake_recursive)$(Q) \
-	$(RUNRUBY) -r./$(arch)-fake -r$(tooldir)/lib/_tmpdir \
-		$(srcdir)/spec/mspec/bin/mspec run -B $(srcdir)/spec/default.mspec -B $(srcdir)/spec/prism.mspec $(MSPECOPT) $(SPECOPTS)
-	$(ACTIONS_ENDGROUP)
-no-test-prism-spec:
-
 check: $(DOT_WAIT) test-spec
 
 RUNNABLE = $(LIBRUBY_RELATIVE:no=un)-runnable
diff --git a/spec/prism.mspec b/spec/prism.mspec
deleted file mode 100644
index 42956c6e7bc353..00000000000000
--- a/spec/prism.mspec
+++ /dev/null
@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# We need to respect the eval coverage setting.
-MSpec.register(:exclude, "Coverage.result returns the correct results when eval coverage is disabled")

From 012b764f7c13d786b7a9340f93a2aaf24c87dc95 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 15:20:44 -0400
Subject: [PATCH 111/242] [ruby/prism] Fix up regexp escapes with control/meta
 and x

https://github.com/ruby/prism/commit/1dbbbedf55
---
 prism/prism.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index bad6c7ff2ba621..3bd761928f8a00 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -9396,7 +9396,7 @@ escape_unicode(pm_parser_t *parser, const uint8_t *string, size_t length) {
  */
 static inline uint8_t
 escape_byte(uint8_t value, const uint8_t flags) {
-    if (flags & PM_ESCAPE_FLAG_CONTROL) value &= 0x1f;
+    if (flags & PM_ESCAPE_FLAG_CONTROL) value &= 0x9f;
     if (flags & PM_ESCAPE_FLAG_META) value |= 0x80;
     return value;
 }
@@ -9632,11 +9632,16 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                     parser->current.end++;
                 }
 
+                value = escape_byte(value, flags);
                 if (flags & PM_ESCAPE_FLAG_REGEXP) {
-                    pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
+                    if (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) {
+                        pm_buffer_append_format(regular_expression_buffer, "\\x%02X", value);
+                    } else {
+                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
+                    }
                 }
 
-                escape_write_byte_encoded(parser, buffer, escape_byte(value, flags));
+                escape_write_byte_encoded(parser, buffer, value);
             } else {
                 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_HEXADECIMAL);
             }

From 7c2c528d350cb5497a2358bdb5684c4822b0f239 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 15:29:06 -0400
Subject: [PATCH 112/242] [ruby/prism] Fix up regexp escapes with control/meta

https://github.com/ruby/prism/commit/8a7afa6988
---
 prism/prism.c | 41 +++++++++++++----------------------------
 1 file changed, 13 insertions(+), 28 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 3bd761928f8a00..cf8ce7c8301a40 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -9496,22 +9496,7 @@ escape_write_escape_encoded(pm_parser_t *parser, pm_buffer_t *buffer) {
 static inline void
 escape_write_byte(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expression_buffer, uint8_t flags, uint8_t byte) {
     if (flags & PM_ESCAPE_FLAG_REGEXP) {
-        pm_buffer_append_bytes(regular_expression_buffer, (const uint8_t *) "\\x", 2);
-
-        uint8_t byte1 = (uint8_t) ((byte >> 4) & 0xF);
-        uint8_t byte2 = (uint8_t) (byte & 0xF);
-
-        if (byte1 >= 0xA) {
-            pm_buffer_append_byte(regular_expression_buffer, (uint8_t) ((byte1 - 0xA) + 'A'));
-        } else {
-            pm_buffer_append_byte(regular_expression_buffer, (uint8_t) (byte1 + '0'));
-        }
-
-        if (byte2 >= 0xA) {
-            pm_buffer_append_byte(regular_expression_buffer, (uint8_t) (byte2 - 0xA + 'A'));
-        } else {
-            pm_buffer_append_byte(regular_expression_buffer, (uint8_t) (byte2 + '0'));
-        }
+        pm_buffer_append_format(regular_expression_buffer, "\\x%02X", byte);
     }
 
     escape_write_byte_encoded(parser, buffer, byte);
@@ -9546,57 +9531,57 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
     switch (peek(parser)) {
         case '\\': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\\', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\\', flags));
             return;
         }
         case '\'': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\'', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\'', flags));
             return;
         }
         case 'a': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\a', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\a', flags));
             return;
         }
         case 'b': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\b', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\b', flags));
             return;
         }
         case 'e': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\033', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\033', flags));
             return;
         }
         case 'f': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\f', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\f', flags));
             return;
         }
         case 'n': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\n', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\n', flags));
             return;
         }
         case 'r': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\r', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\r', flags));
             return;
         }
         case 's': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte(' ', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(' ', flags));
             return;
         }
         case 't': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\t', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\t', flags));
             return;
         }
         case 'v': {
             parser->current.end++;
-            escape_write_byte_encoded(parser, buffer, escape_byte('\v', flags));
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\v', flags));
             return;
         }
         case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': {
@@ -9613,7 +9598,7 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expre
                 }
             }
 
-            escape_write_byte_encoded(parser, buffer, value);
+            escape_write_byte(parser, buffer, regular_expression_buffer, flags, value);
             return;
         }
         case 'x': {

From f021bcdbbe69d324b36c03dab4d2347608658b86 Mon Sep 17 00:00:00 2001
From: Jeremy Evans <code@jeremyevans.net>
Date: Fri, 10 May 2024 12:51:30 -0700
Subject: [PATCH 113/242] Add allocation tests for ruby2_keywords

This tests ruby2_keywords flagged methods, as well as passing
ruby2_keywords flagged hashes to other methods.

Some of the behavior here is questionable, such as allocating
different numbers of objects depending on whether a block is
passed or whether YJIT is enabled. I think there are likely ways
to eliminate allocations in certain cases.  However, this gives
us a baseline and shows us where it is possible to make
improvements.
---
 test/ruby/test_allocation.rb | 121 +++++++++++++++++++++++++++++++++++
 1 file changed, 121 insertions(+)

diff --git a/test/ruby/test_allocation.rb b/test/ruby/test_allocation.rb
index 48348c0fbd514d..8f6858f1cf7bdd 100644
--- a/test/ruby/test_allocation.rb
+++ b/test/ruby/test_allocation.rb
@@ -25,6 +25,10 @@ def self.num_allocations
           empty_array = empty_array = []
           empty_hash = empty_hash = {}
           array1 = array1 = [1]
+          r2k_array = r2k_array = [Hash.ruby2_keywords_hash(a: 3)]
+          r2k_array1 = r2k_array1 = [1, Hash.ruby2_keywords_hash(a: 3)]
+          r2k_empty_array = r2k_empty_array = [Hash.ruby2_keywords_hash({})]
+          r2k_empty_array1 = r2k_empty_array1 = [1, Hash.ruby2_keywords_hash({})]
           hash1 = hash1 = {a: 2}
           nill = nill = nil
           block = block = lambda{}
@@ -95,6 +99,8 @@ def self.none(#{only_block}); end
         check_allocations(1, 0, "none(*empty_array, *empty_array#{block})")
         check_allocations(0, 1, "none(**empty_hash, **empty_hash#{block})")
         check_allocations(1, 1, "none(*empty_array, *empty_array, **empty_hash, **empty_hash#{block})")
+
+        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "none(*r2k_empty_array#{block})")
       RUBY
     end
 
@@ -114,6 +120,9 @@ def self.required(x#{block}); end
         check_allocations(0, 1, "required(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "required(*array1, *empty_array, **empty_hash#{block})")
 
+        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "required(*r2k_empty_array1#{block})")
+        check_allocations(0, 1, "required(*r2k_array#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "required(*empty_array, **hash1, **empty_hash#{block})")
       RUBY
@@ -135,6 +144,10 @@ def self.optional(x=nil#{block}); end
         check_allocations(0, 1, "optional(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "optional(*array1, *empty_array, **empty_hash#{block})")
 
+        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "optional(*r2k_empty_array#{block})")
+        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "optional(*r2k_empty_array1#{block})")
+        check_allocations(0, 1, "optional(*r2k_array#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "optional(*empty_array, **hash1, **empty_hash#{block})")
       RUBY
@@ -166,6 +179,11 @@ def self.splat(*x#{block}); end
         check_allocations(1, 1, "splat(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "splat(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "splat(*empty_array, **hash1, **empty_hash#{block})")
+
+        check_allocations(1, 1, "splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "splat(*r2k_array#{block})")
+        check_allocations(1, 1, "splat(*r2k_array1#{block})")
       RUBY
     end
 
@@ -195,6 +213,10 @@ def self.req_splat(x, *y#{block}); end
         check_allocations(1, 1, "req_splat(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "req_splat(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "req_splat(*empty_array, **hash1, **empty_hash#{block})")
+
+        check_allocations(1, 1, "req_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "req_splat(*r2k_array#{block})")
+        check_allocations(1, 1, "req_splat(*r2k_array1#{block})")
       RUBY
     end
 
@@ -224,6 +246,10 @@ def self.splat_post(*x, y#{block}); end
         check_allocations(1, 1, "splat_post(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "splat_post(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "splat_post(*empty_array, **hash1, **empty_hash#{block})")
+
+        check_allocations(1, 1, "splat_post(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "splat_post(*r2k_array#{block})")
+        check_allocations(1, 1, "splat_post(*r2k_array1#{block})")
       RUBY
     end
 
@@ -251,6 +277,9 @@ def self.keyword(a: nil#{block}); end
         check_allocations(0, 1, "keyword(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "keyword(*empty_array, *empty_array, **empty_hash#{block})")
 
+        check_allocations(1, 1, "keyword(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "keyword(*r2k_array#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "keyword(*empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "keyword(*empty_array, **hash1, **empty_hash#{block})")
@@ -281,6 +310,9 @@ def self.keyword_splat(**kw#{block}); end
         check_allocations(0, 1, "keyword_splat(**hash1, **empty_hash#{block})")
         check_allocations(1, 1, "keyword_splat(*empty_array, *empty_array, **empty_hash#{block})")
 
+        check_allocations(1, 1, "keyword_splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "keyword_splat(*r2k_array#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "keyword_splat(*empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "keyword_splat(*empty_array, **hash1, **empty_hash#{block})")
@@ -311,6 +343,9 @@ def self.keyword_and_keyword_splat(a: 1, **kw#{block}); end
         check_allocations(0, 1, "keyword_and_keyword_splat(**hash1, **empty_hash#{block})")
         check_allocations(1, 1, "keyword_and_keyword_splat(*empty_array, *empty_array, **empty_hash#{block})")
 
+        check_allocations(1, 1, "keyword_and_keyword_splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "keyword_and_keyword_splat(*r2k_array#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "keyword_and_keyword_splat(*empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "keyword_and_keyword_splat(*empty_array, **hash1, **empty_hash#{block})")
@@ -350,6 +385,9 @@ def self.required_and_keyword(b, a: nil#{block}); end
         check_allocations(1, 1, "required_and_keyword(*array1, *empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "required_and_keyword(*array1, *empty_array, **hash1, **empty_hash#{block})")
 
+        check_allocations(1, 1, "required_and_keyword(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "required_and_keyword(*r2k_array1#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "required_and_keyword(1, *empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "required_and_keyword(1, *empty_array, **hash1, **empty_hash#{block})")
@@ -397,6 +435,11 @@ def self.splat_and_keyword(*b, a: nil#{block}); end
         check_allocations(1, 1, "splat_and_keyword(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "splat_and_keyword(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "splat_and_keyword(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "splat_and_keyword(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "splat_and_keyword(*r2k_array#{block})")
+        check_allocations(1, 1, "splat_and_keyword(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "splat_and_keyword(*r2k_array1#{block})")
       RUBY
     end
 
@@ -433,6 +476,9 @@ def self.required_and_keyword_splat(b, **kw#{block}); end
         check_allocations(1, 1, "required_and_keyword_splat(*array1, *empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "required_and_keyword_splat(*array1, *empty_array, **hash1, **empty_hash#{block})")
 
+        check_allocations(1, 1, "required_and_keyword_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "required_and_keyword_splat(*r2k_array1#{block})")
+
         # Currently allocates 1 array unnecessarily due to splatarray true
         check_allocations(1, 1, "required_and_keyword_splat(1, *empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "required_and_keyword_splat(1, *empty_array, **hash1, **empty_hash#{block})")
@@ -480,6 +526,11 @@ def self.splat_and_keyword_splat(*b, **kw#{block}); end
         check_allocations(1, 1, "splat_and_keyword_splat(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "splat_and_keyword_splat(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 1, "splat_and_keyword_splat(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "splat_and_keyword_splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "splat_and_keyword_splat(*r2k_array#{block})")
+        check_allocations(1, 1, "splat_and_keyword_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "splat_and_keyword_splat(*r2k_array1#{block})")
       RUBY
     end
 
@@ -521,6 +572,11 @@ def self.anon_splat_and_anon_keyword_splat(*, **#{block}); end
         check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "anon_splat_and_anon_keyword_splat(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_array#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_array1#{block})")
       RUBY
     end
 
@@ -562,6 +618,11 @@ def self.anon_splat_and_anon_keyword_splat(*, **#{block}); t(*, **) end; def sel
         check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "anon_splat_and_anon_keyword_splat(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_array#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "anon_splat_and_anon_keyword_splat(*r2k_array1#{block})")
       RUBY
     end
 
@@ -603,6 +664,11 @@ def self.argument_forwarding(...); end
         check_allocations(1, 1, "argument_forwarding(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "argument_forwarding(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "argument_forwarding(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "argument_forwarding(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_array#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_array1#{block})")
       RUBY
     end
 
@@ -644,6 +710,61 @@ def self.argument_forwarding(...); t(...) end; def self.t(...) end
         check_allocations(1, 1, "argument_forwarding(*array1, **empty_hash, a: 2#{block})")
         check_allocations(1, 1, "argument_forwarding(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "argument_forwarding(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "argument_forwarding(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_array#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_empty_array1#{block})")
+        check_allocations(1, 1, "argument_forwarding(*r2k_array1#{block})")
+      RUBY
+    end
+
+    def test_ruby2_keywords
+      check_allocations(<<~RUBY)
+        def self.r2k(*a#{block}); end
+        singleton_class.send(:ruby2_keywords, :r2k)
+
+        check_allocations(1, 1, "r2k(1, a: 2#{block})")
+        check_allocations(1, 1, "r2k(1, *empty_array, a: 2#{block})")
+        check_allocations(1, 1, "r2k(1, a:2, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(1, **empty_hash, a: 2#{block})")
+
+        check_allocations(1, 0, "r2k(1, **nil#{block})")
+        check_allocations(1, 1, "r2k(1, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(1, **hash1#{block})")
+        check_allocations(1, 1, "r2k(1, *empty_array, **hash1#{block})")
+        check_allocations(1, 1, "r2k(1, **hash1, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(1, **empty_hash, **hash1#{block})")
+
+        check_allocations(1, 0, "r2k(1, *empty_array#{block})")
+        check_allocations(1, 1, "r2k(1, **hash1, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(1, *empty_array, *empty_array, **empty_hash#{block})")
+
+        check_allocations(1, 1, "r2k(*array1, a: 2#{block})")
+
+        check_allocations(1, 0, "r2k(*array1, **nill#{block})")
+        check_allocations(1, 1, "r2k(*array1, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(*array1, **hash1#{block})")
+        check_allocations(1, 1, "r2k(*array1, *empty_array, **hash1#{block})")
+
+        check_allocations(1, 0, "r2k(*array1, *empty_array#{block})")
+        check_allocations(1, 1, "r2k(*array1, *empty_array, **empty_hash#{block})")
+
+        check_allocations(1, 1, "r2k(*array1, *empty_array, a: 2, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(*array1, *empty_array, **hash1, **empty_hash#{block})")
+
+        check_allocations(1, 1, "r2k(1, *empty_array, a: 2, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(1, *empty_array, **hash1, **empty_hash#{block})")
+        check_allocations(1, 1, "r2k(*array1, **empty_hash, a: 2#{block})")
+        check_allocations(1, 1, "r2k(*array1, **hash1, **empty_hash#{block})")
+        check_allocations(1, 0, "r2k(*array1, **nil#{block})")
+
+        check_allocations(1, 1, "r2k(*r2k_empty_array#{block})")
+        check_allocations(1, 1, "r2k(*r2k_array#{block})")
+        unless defined?(RubyVM::YJIT.enabled?) && RubyVM::YJIT.enabled?
+          # YJIT may or may not allocate depending on arch?
+          check_allocations(1, 1, "r2k(*r2k_empty_array1#{block})")
+          check_allocations(1, 1, "r2k(*r2k_array1#{block})")
+        end
       RUBY
     end
 

From 2433b57b6a3a6f8e65f61c27d707e1c7f5407986 Mon Sep 17 00:00:00 2001
From: Jeremy Evans <code@jeremyevans.net>
Date: Sat, 11 May 2024 12:12:52 -0700
Subject: [PATCH 114/242] Avoid hash allocation for empty ruby2_keywords
 flagged keyword hash

If the method being called does not have a keyword splat parameter,
there is no point in allocating the hash, because the hash will
be unused (as empty keyword hashes are ignored).
---
 test/ruby/test_allocation.rb | 28 ++++++++++++++--------------
 vm_args.c                    |  4 +++-
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/test/ruby/test_allocation.rb b/test/ruby/test_allocation.rb
index 8f6858f1cf7bdd..ab3ae15a9f05bc 100644
--- a/test/ruby/test_allocation.rb
+++ b/test/ruby/test_allocation.rb
@@ -100,7 +100,7 @@ def self.none(#{only_block}); end
         check_allocations(0, 1, "none(**empty_hash, **empty_hash#{block})")
         check_allocations(1, 1, "none(*empty_array, *empty_array, **empty_hash, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "none(*r2k_empty_array#{block})")
+        check_allocations(#{block.empty?} ? 0 : 1, 0, "none(*r2k_empty_array#{block})")
       RUBY
     end
 
@@ -120,7 +120,7 @@ def self.required(x#{block}); end
         check_allocations(0, 1, "required(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "required(*array1, *empty_array, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "required(*r2k_empty_array1#{block})")
+        check_allocations(#{block.empty?} ? 0 : 1, 0, "required(*r2k_empty_array1#{block})")
         check_allocations(0, 1, "required(*r2k_array#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
@@ -144,8 +144,8 @@ def self.optional(x=nil#{block}); end
         check_allocations(0, 1, "optional(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "optional(*array1, *empty_array, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "optional(*r2k_empty_array#{block})")
-        check_allocations(#{block.empty?} ? 0 : 1, #{block.empty?} ? 0 : 1, "optional(*r2k_empty_array1#{block})")
+        check_allocations(#{block.empty?} ? 0 : 1, 0, "optional(*r2k_empty_array#{block})")
+        check_allocations(#{block.empty?} ? 0 : 1, 0, "optional(*r2k_empty_array1#{block})")
         check_allocations(0, 1, "optional(*r2k_array#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
@@ -180,8 +180,8 @@ def self.splat(*x#{block}); end
         check_allocations(1, 0, "splat(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "splat(*empty_array, **hash1, **empty_hash#{block})")
 
-        check_allocations(1, 1, "splat(*r2k_empty_array#{block})")
-        check_allocations(1, 1, "splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 0, "splat(*r2k_empty_array#{block})")
+        check_allocations(1, 0, "splat(*r2k_empty_array1#{block})")
         check_allocations(1, 1, "splat(*r2k_array#{block})")
         check_allocations(1, 1, "splat(*r2k_array1#{block})")
       RUBY
@@ -214,7 +214,7 @@ def self.req_splat(x, *y#{block}); end
         check_allocations(1, 0, "req_splat(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "req_splat(*empty_array, **hash1, **empty_hash#{block})")
 
-        check_allocations(1, 1, "req_splat(*r2k_empty_array1#{block})")
+        check_allocations(1, 0, "req_splat(*r2k_empty_array1#{block})")
         check_allocations(1, 1, "req_splat(*r2k_array#{block})")
         check_allocations(1, 1, "req_splat(*r2k_array1#{block})")
       RUBY
@@ -247,7 +247,7 @@ def self.splat_post(*x, y#{block}); end
         check_allocations(1, 0, "splat_post(*array1, *empty_array, **empty_hash#{block})")
         check_allocations(1, 1, "splat_post(*empty_array, **hash1, **empty_hash#{block})")
 
-        check_allocations(1, 1, "splat_post(*r2k_empty_array1#{block})")
+        check_allocations(1, 0, "splat_post(*r2k_empty_array1#{block})")
         check_allocations(1, 1, "splat_post(*r2k_array#{block})")
         check_allocations(1, 1, "splat_post(*r2k_array1#{block})")
       RUBY
@@ -277,7 +277,7 @@ def self.keyword(a: nil#{block}); end
         check_allocations(0, 1, "keyword(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "keyword(*empty_array, *empty_array, **empty_hash#{block})")
 
-        check_allocations(1, 1, "keyword(*r2k_empty_array#{block})")
+        check_allocations(1, 0, "keyword(*r2k_empty_array#{block})")
         check_allocations(1, 1, "keyword(*r2k_array#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
@@ -385,7 +385,7 @@ def self.required_and_keyword(b, a: nil#{block}); end
         check_allocations(1, 1, "required_and_keyword(*array1, *empty_array, a: 2, **empty_hash#{block})")
         check_allocations(1, 1, "required_and_keyword(*array1, *empty_array, **hash1, **empty_hash#{block})")
 
-        check_allocations(1, 1, "required_and_keyword(*r2k_empty_array1#{block})")
+        check_allocations(1, 0, "required_and_keyword(*r2k_empty_array1#{block})")
         check_allocations(1, 1, "required_and_keyword(*r2k_array1#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
@@ -436,9 +436,9 @@ def self.splat_and_keyword(*b, a: nil#{block}); end
         check_allocations(1, 1, "splat_and_keyword(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "splat_and_keyword(*array1, **nil#{block})")
 
-        check_allocations(1, 1, "splat_and_keyword(*r2k_empty_array#{block})")
+        check_allocations(1, 0, "splat_and_keyword(*r2k_empty_array#{block})")
         check_allocations(1, 1, "splat_and_keyword(*r2k_array#{block})")
-        check_allocations(1, 1, "splat_and_keyword(*r2k_empty_array1#{block})")
+        check_allocations(1, 0, "splat_and_keyword(*r2k_empty_array1#{block})")
         check_allocations(1, 1, "splat_and_keyword(*r2k_array1#{block})")
       RUBY
     end
@@ -758,11 +758,11 @@ def self.r2k(*a#{block}); end
         check_allocations(1, 1, "r2k(*array1, **hash1, **empty_hash#{block})")
         check_allocations(1, 0, "r2k(*array1, **nil#{block})")
 
-        check_allocations(1, 1, "r2k(*r2k_empty_array#{block})")
+        check_allocations(1, 0, "r2k(*r2k_empty_array#{block})")
         check_allocations(1, 1, "r2k(*r2k_array#{block})")
         unless defined?(RubyVM::YJIT.enabled?) && RubyVM::YJIT.enabled?
           # YJIT may or may not allocate depending on arch?
-          check_allocations(1, 1, "r2k(*r2k_empty_array1#{block})")
+          check_allocations(1, 0, "r2k(*r2k_empty_array1#{block})")
           check_allocations(1, 1, "r2k(*r2k_array1#{block})")
         end
       RUBY
diff --git a/vm_args.c b/vm_args.c
index 1a78e96776d53b..1db62dc7e28340 100644
--- a/vm_args.c
+++ b/vm_args.c
@@ -684,7 +684,9 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
             if (RB_TYPE_P(rest_last, T_HASH) && FL_TEST_RAW(rest_last, RHASH_PASS_AS_KEYWORDS)) {
                 // def f(**kw); a = [..., kw]; g(*a)
                 splat_flagged_keyword_hash = rest_last;
-                rest_last = rb_hash_dup(rest_last);
+                if (!RHASH_EMPTY_P(rest_last) || (ISEQ_BODY(iseq)->param.flags.has_kwrest)) {
+                    rest_last = rb_hash_dup(rest_last);
+                }
                 kw_flag |= VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT;
 
                 // Unset rest_dupped set by anon_rest as we may need to modify splat in this case

From 86cf074fa1dcf73846e094775414d661e47dfc76 Mon Sep 17 00:00:00 2001
From: Jeremy Evans <code@jeremyevans.net>
Date: Tue, 14 May 2024 17:03:46 -0700
Subject: [PATCH 115/242] Avoid array allocation for empty ruby2_keywords
 flagged keyword hash

If the method being called does not have a positional splat
parameter, there is no point in allocating the array, as
decrementing given_argc is sufficient to ensure the empty keyword
hash is not considered an argument, assuming that we are calling
a method/lambda and not a regular proc.
---
 test/ruby/test_allocation.rb | 8 ++++----
 vm_args.c                    | 7 +++++--
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/test/ruby/test_allocation.rb b/test/ruby/test_allocation.rb
index ab3ae15a9f05bc..fbe0548899dc86 100644
--- a/test/ruby/test_allocation.rb
+++ b/test/ruby/test_allocation.rb
@@ -100,7 +100,7 @@ def self.none(#{only_block}); end
         check_allocations(0, 1, "none(**empty_hash, **empty_hash#{block})")
         check_allocations(1, 1, "none(*empty_array, *empty_array, **empty_hash, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, 0, "none(*r2k_empty_array#{block})")
+        check_allocations(0, 0, "none(*r2k_empty_array#{block})")
       RUBY
     end
 
@@ -120,7 +120,7 @@ def self.required(x#{block}); end
         check_allocations(0, 1, "required(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "required(*array1, *empty_array, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, 0, "required(*r2k_empty_array1#{block})")
+        check_allocations(0, 0, "required(*r2k_empty_array1#{block})")
         check_allocations(0, 1, "required(*r2k_array#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
@@ -144,8 +144,8 @@ def self.optional(x=nil#{block}); end
         check_allocations(0, 1, "optional(**hash1, **empty_hash#{block})")
         check_allocations(1, 0, "optional(*array1, *empty_array, **empty_hash#{block})")
 
-        check_allocations(#{block.empty?} ? 0 : 1, 0, "optional(*r2k_empty_array#{block})")
-        check_allocations(#{block.empty?} ? 0 : 1, 0, "optional(*r2k_empty_array1#{block})")
+        check_allocations(0, 0, "optional(*r2k_empty_array#{block})")
+        check_allocations(0, 0, "optional(*r2k_empty_array1#{block})")
         check_allocations(0, 1, "optional(*r2k_array#{block})")
 
         # Currently allocates 1 array unnecessarily due to splatarray true
diff --git a/vm_args.c b/vm_args.c
index 1db62dc7e28340..0c1a26cfadc6aa 100644
--- a/vm_args.c
+++ b/vm_args.c
@@ -693,8 +693,11 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
                 args->rest_dupped = false;
 
                 if (ignore_keyword_hash_p(rest_last, iseq, &kw_flag, &converted_keyword_hash)) {
-                    arg_rest_dup(args);
-                    rb_ary_pop(args->rest);
+                    if (ISEQ_BODY(iseq)->param.flags.has_rest || arg_setup_type != arg_setup_method) {
+                        // Only duplicate/modify splat array if it will be used
+                        arg_rest_dup(args);
+                        rb_ary_pop(args->rest);
+                    }
                     given_argc--;
                     kw_flag &= ~(VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
                 }

From e82c7a0577cb9574fbe748a381c9d6fa75e9211d Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 15:22:45 -0400
Subject: [PATCH 116/242] [PRISM] Enable
 TestRegexp#test_match_control_meta_escape

---
 test/.excludes-prism/TestRegexp.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestRegexp.rb b/test/.excludes-prism/TestRegexp.rb
index 5852d870efed6e..9d514236c73eee 100644
--- a/test/.excludes-prism/TestRegexp.rb
+++ b/test/.excludes-prism/TestRegexp.rb
@@ -1,2 +1 @@
 exclude(:test_unescape, "unescapes in regexp missing some bytes")
-exclude(:test_match_control_meta_escape, "unescapes in regexp missing some bytes")

From 6ddc0a8044929751146c667be4d777c02ed52667 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Mon, 20 May 2024 15:40:40 -0400
Subject: [PATCH 117/242] [PRISM] Enable TestRegexp#test_unescape

---
 test/.excludes-prism/TestRegexp.rb | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 test/.excludes-prism/TestRegexp.rb

diff --git a/test/.excludes-prism/TestRegexp.rb b/test/.excludes-prism/TestRegexp.rb
deleted file mode 100644
index 9d514236c73eee..00000000000000
--- a/test/.excludes-prism/TestRegexp.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_unescape, "unescapes in regexp missing some bytes")

From 30aa300f84388c78e951a1314c80e575e68754b1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 21 May 2024 02:13:47 +0000
Subject: [PATCH 118/242] --- updated-dependencies: - dependency-name:
 github/codeql-action   dependency-type: direct:production   update-type:
 version-update:semver-patch ...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/codeql-analysis.yml | 8 ++++----
 .github/workflows/scorecards.yml      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index d6a2e297be3d59..7d12c1fe811b8b 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -80,15 +80,15 @@ jobs:
         run: sudo rm /usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
+        uses: github/codeql-action/init@9fdb3e49720b44c48891d036bb502feb25684276 # v3.25.6
         with:
           languages: ${{ matrix.language }}
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
+        uses: github/codeql-action/autobuild@9fdb3e49720b44c48891d036bb502feb25684276 # v3.25.6
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
+        uses: github/codeql-action/analyze@9fdb3e49720b44c48891d036bb502feb25684276 # v3.25.6
         with:
           category: '/language:${{ matrix.language }}'
           upload: False
@@ -118,7 +118,7 @@ jobs:
         continue-on-error: true
 
       - name: Upload SARIF
-        uses: github/codeql-action/upload-sarif@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v3.25.5
+        uses: github/codeql-action/upload-sarif@9fdb3e49720b44c48891d036bb502feb25684276 # v3.25.6
         with:
           sarif_file: sarif-results/${{ matrix.language }}.sarif
         continue-on-error: true
diff --git a/.github/workflows/scorecards.yml b/.github/workflows/scorecards.yml
index 85ee3e2a48c007..eeff61d558bfb5 100644
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -67,6 +67,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: 'Upload to code-scanning'
-        uses: github/codeql-action/upload-sarif@b7cec7526559c32f1616476ff32d17ba4c59b2d6 # v2.1.27
+        uses: github/codeql-action/upload-sarif@9fdb3e49720b44c48891d036bb502feb25684276 # v2.1.27
         with:
           sarif_file: results.sarif

From 5fed63f7b09d7697a34fcc38efc2985d6e805c40 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 9 May 2024 12:00:29 +0900
Subject: [PATCH 119/242] ripper: Use ripper DSL in simple dispatch chain cases

---
 parse.y | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/parse.y b/parse.y
index 9b363171ed4572..2080110c036233 100644
--- a/parse.y
+++ b/parse.y
@@ -4056,12 +4056,7 @@ arg		: lhs '=' lex_ctxt arg_rhs
                 | tUMINUS_NUM simple_numeric tPOW arg
                     {
                         $$ = call_uni_op(p, call_bin_op(p, $2, idPow, $4, &@2, &@$), idUMinus, &@1, &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch3(binary, get_value($:2), ID2VAL(idPow), get_value($:4));
-                        val = dispatch2(unary, ID2VAL(idUMinus), val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: unary!(ID2VAL(idUMinus), binary!($:2, ID2VAL(idPow), $:4)) %*/
                     }
                 | tUPLUS arg
                     {
@@ -5226,12 +5221,7 @@ block_param_def	: '|' opt_bv_decl '|'
                         p->max_numparam = ORDINAL_PARAM;
                         p->ctxt.in_argdef = 0;
                         $$ = 0;
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch7(params, Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil);
-                        val = dispatch2(block_var, val, get_value($:2));
-                        set_value(val);
-                    %*/
+                    /*% ripper: block_var!(params!(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil), $:2) %*/
                     }
                 | '|' block_param opt_bv_decl '|'
                     {

From 2d92a4afba36034f3d92ab75dfae4dbf5a445c7e Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Fri, 10 May 2024 20:02:16 +0900
Subject: [PATCH 120/242] ripper: Make `$:n` to refer each grammar values

Ripper DSL uses these values for callbacks, but does not need indexes.
---
 ext/ripper/tools/dsl.rb |  16 +-
 parse.y                 | 423 +++++++++++++++++-----------------------
 2 files changed, 186 insertions(+), 253 deletions(-)

diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index d0002d1ec3a184..d090b15c0bf3b2 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -42,7 +42,15 @@ def initialize(code, options, lineno = nil)
     p = p = "p"
 
     @code = +""
-    code = code.gsub(%r[\G#{NOT_REF_PATTERN}\K(\$|\$:|@)#{TAG_PATTERN}?#{NAME_PATTERN}]o, '"\&"')
+    code = code.gsub(%r[\G#{NOT_REF_PATTERN}\K(\$|\$:|@)#{TAG_PATTERN}?#{NAME_PATTERN}]o) {
+      if (arg = $&) == "$:$"
+        '"p->s_lvalue"'
+      elsif arg.start_with?("$:")
+        %["get_value(#{arg})"]
+      else
+        arg.dump
+      end
+    }
     @last_value = eval(code)
   rescue SyntaxError
     $stderr.puts "error on line #{@lineno}" if @lineno
@@ -77,11 +85,7 @@ def add_event(event, args, qundef_check = false)
     vars = []
     args.each do |arg|
       vars << v = new_var
-      if arg =~ /\A\$:#{NAME_PATTERN}\z/
-        @code << "#{ v }=get_value(#{arg});"
-      else
-        @code << "#{ v }=#{ arg };"
-      end
+      @code << "#{ v }=#{ arg };"
     end
     v = new_var
     d = "dispatch#{ args.size }(#{ [event, *vars].join(",") })"
diff --git a/parse.y b/parse.y
index 2080110c036233..4f295eb12fef4e 100644
--- a/parse.y
+++ b/parse.y
@@ -1488,14 +1488,12 @@ static NODE *heredoc_dedent(struct parser_params*,NODE*);
 static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYPE *loc);
 
 #ifdef RIPPER
-static VALUE var_field(struct parser_params *p, VALUE a);
 #define get_value(idx) (rb_ary_entry(p->s_value_stack, idx))
 #define set_value(val) (p->s_lvalue = val)
 static VALUE defs(struct parser_params *p, VALUE head, VALUE args, VALUE bodystmt);
 static VALUE backref_error(struct parser_params*, NODE *, VALUE);
 static VALUE ripper_assignable(struct parser_params *p, ID id, VALUE lhs);
 static VALUE ripper_const_decl(struct parser_params *p, VALUE path);
-static VALUE ripper_heredoc_dedent(struct parser_params *p, int indent, VALUE array);
 static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
 static int id_is_var(struct parser_params *p, ID id);
 #endif
@@ -1611,7 +1609,7 @@ void ripper_error(struct parser_params *p);
 
 #define yyparse ripper_yyparse
 
-static void ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs);
+static VALUE ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs);
 
 static VALUE
 ripper_new_args(struct parser_params *p, VALUE pre_args, VALUE opt_args, VALUE rest_arg, VALUE post_args, VALUE tail)
@@ -2990,43 +2988,43 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
                                         p->cur_arg = 0;
                                         p->ctxt.in_argdef = 1;
                                         $$ = NEW_OPT_ARG(assignable(p, $1, $3, &@$), &@$);
-                                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, get_value($:1)), get_value($:3)) %*/
+                                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:3) %*/
                                     }
                                 ;
 
 %rule f_optarg(value) <node_opt_arg>: f_opt(value)
                                         {
                                             $$ = $1;
-                                        /*% ripper: rb_ary_new3(1, get_value($:1)) %*/
+                                        /*% ripper: rb_ary_new3(1, $:1) %*/
                                         }
                                     | f_optarg(value) ',' f_opt(value)
                                         {
                                             $$ = opt_arg_append($1, $3);
-                                        /*% ripper: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                                        /*% ripper: rb_ary_push($:1, $:3) %*/
                                         }
                                     ;
 
 %rule f_kwarg(kw) <node_kw_arg>: kw
                                     {
                                         $$ = $1;
-                                    /*% ripper: rb_ary_new3(1, get_value($:1)) %*/
+                                    /*% ripper: rb_ary_new3(1, $:1) %*/
                                     }
                                 | f_kwarg(kw) ',' kw
                                     {
                                         $$ = kwd_append($1, $3);
-                                    /*% ripper: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                                    /*% ripper: rb_ary_push($:1, $:3) %*/
                                     }
                                 ;
 
 %rule opt_args_tail(tail) <node_args>: ',' tail
                                         {
                                             $$ = $2;
-                                        /*% ripper: get_value($:2); %*/
+                                        /*% ripper: $:2 %*/
                                         }
                                     | /* none */
                                         {
                                             $$ = new_args_tail(p, 0, 0, 0, &@0);
-                                        /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, Qnil); %*/
+                                        /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, Qnil) %*/
                                         }
                                     ;
 
@@ -3095,7 +3093,7 @@ top_stmt	: stmt
                 | keyword_BEGIN begin_block
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
@@ -3184,7 +3182,7 @@ k_END		: keyword_END lex_ctxt
                     {
                         $$ = $2;
                         p->ctxt.in_rescue = before_rescue;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     };
 
 stmt		: keyword_alias fitem {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);} fitem
@@ -3355,12 +3353,8 @@ command_asgn	: lhs '=' lex_ctxt command_rhs
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFN($$)->nd_defn = $bodystmt;
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch4(bodystmt, get_value($:bodystmt), Qnil, Qnil, Qnil);
-                        val = dispatch3(def, get_value($:head), get_value($:args), val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
+                    /*% ripper: def!($:head, $:args, $:$) %*/
                         local_pop(p);
                     }
                 | defs_head[head] f_opt_paren_args[args] '=' endless_command[bodystmt]
@@ -3370,12 +3364,8 @@ command_asgn	: lhs '=' lex_ctxt command_rhs
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch4(bodystmt, get_value($:bodystmt), Qnil, Qnil, Qnil);
-                        val = defs(p, get_value($:head), get_value($:args), val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
+                    /*% ripper: defs(p, $:head, $:args, $:$) %*/
                         local_pop(p);
                     }
                 | backref tOP_ASGN lex_ctxt command_rhs
@@ -3384,7 +3374,7 @@ command_asgn	: lhs '=' lex_ctxt command_rhs
                         rb_backref_error(p, $1);
                     /*% %*/
                         $$ = NEW_ERROR(&@$);
-                    /*% ripper[error]: backref_error(p, $1, opassign!(var_field(p, get_value($:1)), $:2, $:4)) %*/
+                    /*% ripper[error]: backref_error(p, $1, opassign!(var_field!($:1), $:2, $:4)) %*/
                     }
                 ;
 
@@ -3485,7 +3475,7 @@ defn_head	: k_def def_name
                         $$ = def_head_save(p, $k_def);
                         $$->nd_mid = $def_name;
                         $$->nd_def = NEW_DEFN($def_name, 0, &@$);
-                    /*% ripper: get_value($:def_name); %*/
+                    /*% ripper: $:def_name %*/
                     }
                 ;
 
@@ -3500,10 +3490,7 @@ defs_head	: k_def singleton dot_or_colon
                         $$ = def_head_save(p, $k_def);
                         $$->nd_mid = $def_name;
                         $$->nd_def = NEW_DEFS($singleton, $def_name, 0, &@$);
-                    /*%%%*/
-                    /*%
-                        set_value(rb_ary_new_from_args(3, get_value($:singleton), get_value($:dot_or_colon), get_value($:def_name)));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:singleton, $:dot_or_colon, $:def_name) %*/
                     }
                 ;
 
@@ -3521,7 +3508,7 @@ expr_value	: expr
 expr_value_do	: {COND_PUSH(1);} expr_value do {COND_POP();}
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
@@ -3541,14 +3528,14 @@ cmd_brace_block	: tLBRACE_ARG brace_body '}'
                     {
                         $$ = $2;
                         set_embraced_location($$, &@1, &@3);
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
 fcall		: operation
                     {
                         $$ = NEW_FCALL($1, 0, &@$);
-                    /*% ripper: get_value($:1); %*/
+                    /*% ripper: $:1 %*/
                     }
                 ;
 
@@ -3646,7 +3633,7 @@ mlhs_inner	: mlhs_basic
 mlhs_basic	: mlhs_head
                     {
                         $$ = NEW_MASGN($1, 0, &@$);
-                    /*% ripper: get_value($:1) %*/
+                    /*% ripper: $:1 %*/
                     }
                 | mlhs_head mlhs_item
                     {
@@ -3730,12 +3717,12 @@ mlhs_post	: mlhs_item
 mlhs_node	: user_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | primary_value '[' opt_call_args rbracket
                     {
@@ -3775,19 +3762,19 @@ mlhs_node	: user_variable
                         rb_backref_error(p, $1);
                     /*% %*/
                         $$ = NEW_ERROR(&@$);
-                    /*% ripper[error]: backref_error(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper[error]: backref_error(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
 lhs		: user_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | primary_value '[' opt_call_args rbracket
                     {
@@ -3825,7 +3812,7 @@ lhs		: user_variable
                         rb_backref_error(p, $1);
                     /*% %*/
                         $$ = NEW_ERROR(&@$);
-                    /*% ripper[error]: backref_error(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper[error]: backref_error(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
@@ -3879,13 +3866,13 @@ fitem		: fname
 undef_list	: fitem
                     {
                         $$ = NEW_UNDEF($1, &@$);
-                    /*% ripper: rb_ary_new3(1, get_value($:1)) %*/
+                    /*% ripper: rb_ary_new3(1, $:1) %*/
                     }
                 | undef_list ',' {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);} fitem
                     {
                         NODE *undef = NEW_UNDEF($4, &@4);
                         $$ = block_append(p, $1, undef);
-                    /*% ripper: rb_ary_push(get_value($:1), get_value($:4)) %*/
+                    /*% ripper: rb_ary_push($:1, $:4) %*/
                     }
                 ;
 
@@ -3983,7 +3970,7 @@ arg		: lhs '=' lex_ctxt arg_rhs
                     /*%%%*/
                         $$ = NEW_ERROR(&@$);
                     /*% %*/
-                    /*% ripper[error]: backref_error(p, $1, opassign!(var_field(p, get_value($:1)), $:2, $:4)) %*/
+                    /*% ripper[error]: backref_error(p, $1, opassign!(var_field!($:1), $:2, $:4)) %*/
                     }
                 | arg tDOT2 arg
                     {
@@ -4164,12 +4151,8 @@ arg		: lhs '=' lex_ctxt arg_rhs
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFN($$)->nd_defn = $bodystmt;
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch4(bodystmt, get_value($:bodystmt), Qnil, Qnil, Qnil);
-                        val = dispatch3(def, get_value($:head), get_value($:args), val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
+                    /*% ripper: def!($:head, $:args, $:$) %*/
                         local_pop(p);
                     }
                 | defs_head[head] f_opt_paren_args[args] '=' endless_arg[bodystmt]
@@ -4179,12 +4162,8 @@ arg		: lhs '=' lex_ctxt arg_rhs
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch4(bodystmt, get_value($:bodystmt), Qnil, Qnil, Qnil);
-                        val = defs(p, get_value($:head), get_value($:args), val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
+                    /*% ripper: defs(p, $:head, $:args, $:$) %*/
                         local_pop(p);
                     }
                 | primary
@@ -4394,14 +4373,14 @@ command_args	:   {
                         CMDARG_POP();
                         if (lookahead) CMDARG_PUSH(0);
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
 block_arg	: tAMPER arg_value
                     {
                         $$ = NEW_BLOCK_PASS($2, &@$);
-                    /*% ripper: get_value($:2) %*/
+                    /*% ripper: $:2 %*/
                     }
                 | tAMPER
                     {
@@ -4414,7 +4393,7 @@ block_arg	: tAMPER arg_value
 opt_block_arg	: ',' block_arg
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | none
                     {
@@ -4450,7 +4429,7 @@ args		: arg_value
 arg_splat	: tSTAR arg_value
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | tSTAR /* none */
                     {
@@ -4782,7 +4761,7 @@ primary		: literal
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
-                    /*% ripper: defs(p, get_value($:head), get_value($:args), get_value($:bodystmt)) %*/
+                    /*% ripper: defs(p, $:head, $:args, $:bodystmt) %*/
                         local_pop(p);
                     }
                 | keyword_break
@@ -5029,7 +5008,7 @@ f_marg		: f_norm_arg
                     {
                         $$ = assignable(p, $1, 0, &@$);
                         mark_lvar_used(p, $$);
-                    /*% ripper: ripper_assignable(p, $1, get_value($:1)) %*/
+                    /*% ripper: ripper_assignable(p, $1, $:1) %*/
                     }
                 | tLPAREN f_margs rparen
                     {
@@ -5053,7 +5032,7 @@ f_marg_list	: f_marg
 f_margs		: f_marg_list
                     {
                         $$ = NEW_MASGN($1, 0, &@$);
-                    /*% ripper: get_value($:1) %*/
+                    /*% ripper: $:1 %*/
                     }
                 | f_marg_list ',' f_rest_marg
                     {
@@ -5081,7 +5060,7 @@ f_rest_marg	: tSTAR f_norm_arg
                     {
                         $$ = assignable(p, $2, 0, &@$);
                         mark_lvar_used(p, $$);
-                    /*% ripper: ripper_assignable(p, $2, get_value($:2)) %*/
+                    /*% ripper: ripper_assignable(p, $2, $:2) %*/
                     }
                 | tSTAR
                     {
@@ -5103,22 +5082,22 @@ f_eq		: {p->ctxt.in_argdef = 0;} '=';
 block_args_tail	: f_kwarg(f_block_kw) ',' f_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, $3, $4, &@3);
-                    /*% ripper: rb_ary_new_from_args(3, get_value($:1), get_value($:3), get_value($:4)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, $:3, $:4) %*/
                     }
                 | f_kwarg(f_block_kw) opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, 0, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, get_value($:1), Qnil, get_value($:2)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, $:2) %*/
                     }
                 | f_any_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, 0, $1, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, get_value($:1), get_value($:2)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, $:2) %*/
                     }
                 | f_block_arg
                     {
                         $$ = new_args_tail(p, 0, 0, $1, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, get_value($:1)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, $:1) %*/
                     }
                 ;
 
@@ -5133,78 +5112,78 @@ excessed_comma	: ','
 block_param	: f_arg ',' f_optarg(primary_value) ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, 0, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), get_value($:5), Qnil, get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, Qnil, $:6) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, $7, $8, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), get_value($:5), get_value($:7), get_value($:8)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, $:7, $:8) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), Qnil, Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, Qnil, $:4) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), Qnil, get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, $:5, $:6) %*/
                     }
                 | f_arg ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, get_value($:3), Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, Qnil, $:4) %*/
                     }
                 | f_arg excessed_comma
                     {
                         $$ = new_args_tail(p, 0, 0, 0, &@2);
                         $$ = new_args(p, $1, 0, $2, 0, $$, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, get_value($:2), Qnil, rb_ary_new_from_args(3, Qnil, Qnil, Qnil)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:2, Qnil, rb_ary_new_from_args(3, Qnil, Qnil, Qnil)) %*/
                     }
                 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, get_value($:3), get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, $:5, $:6) %*/
                     }
                 | f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, Qnil, Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, Qnil, Qnil, $:2) %*/
                     }
                 | f_optarg(primary_value) ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), get_value($:3), Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, Qnil, $:4) %*/
                     }
                 | f_optarg(primary_value) ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), get_value($:3), get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, $:5, $:6) %*/
                     }
                 | f_optarg(primary_value) opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), Qnil, Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, Qnil, $:2) %*/
                     }
                 | f_optarg(primary_value) ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), Qnil, get_value($:3), get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, $:3, $:4) %*/
                     }
                 | f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, get_value($:1), Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, Qnil, $:2) %*/
                     }
                 | f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, get_value($:1), get_value($:3), get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, $:3, $:4) %*/
                     }
                 | block_args_tail
                     {
                         $$ = new_args(p, 0, 0, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, get_value($:1)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, $:1) %*/
                     }
                 ;
 
@@ -5242,20 +5221,20 @@ opt_bv_decl	: '\n'?
                 | '\n'? ';' bv_decls '\n'?
                     {
                         $$ = 0;
-                    /*% ripper: get_value($:3) %*/
+                    /*% ripper: $:3 %*/
                     }
                 ;
 
 bv_decls	: bvar
-                    /*% ripper[brace]: rb_ary_new3(1, get_value($:1)) %*/
+                    /*% ripper[brace]: rb_ary_new3(1, $:1) %*/
                 | bv_decls ',' bvar
-                    /*% ripper[brace]: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                    /*% ripper[brace]: rb_ary_push($:1, $:3) %*/
                 ;
 
 bvar		: tIDENTIFIER
                     {
                         new_bv(p, $1);
-                    /*% ripper: get_value($:1) %*/
+                    /*% ripper: $:1 %*/
                     }
                 | f_bad_arg
                     {
@@ -5334,7 +5313,7 @@ lambda_body	: tLAMBEG compstmt '}'
                     {
                         token_info_pop(p, "}", &@3);
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | keyword_do_LAMBDA
                     {
@@ -5343,7 +5322,7 @@ lambda_body	: tLAMBEG compstmt '}'
                   bodystmt k_end
                     {
                         $$ = $3;
-                    /*% ripper: get_value($:3); %*/
+                    /*% ripper: $:3 %*/
                     }
                 ;
 
@@ -5351,7 +5330,7 @@ do_block	: k_do_block do_body k_end
                     {
                         $$ = $2;
                         set_embraced_location($$, &@1, &@3);
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
@@ -5442,13 +5421,13 @@ brace_block	: '{' brace_body '}'
                     {
                         $$ = $2;
                         set_embraced_location($$, &@1, &@3);
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | k_do do_body k_end
                     {
                         $$ = $2;
                         set_embraced_location($$, &@1, &@3);
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
@@ -5579,28 +5558,28 @@ p_top_expr_body : p_expr
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, 0, 0, &@$);
                         $$ = new_array_pattern(p, 0, $1, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, get_value($:1), rb_ary_new()); %*/
+                    /*% ripper: ripper_new_array_pattern(p, Qnil, $:1, rb_ary_new()) %*/
                     }
                 | p_expr ',' p_args
                     {
                         $$ = new_array_pattern(p, 0, $1, $3, &@$);
                         nd_set_first_loc($$, @1.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, get_value($:1), get_value($:3)); %*/
+                    /*% ripper: ripper_new_array_pattern(p, Qnil, $:1, $:3) %*/
                     }
                 | p_find
                     {
                         $$ = new_find_pattern(p, 0, $1, &@$);
-                    /*% ripper: ripper_new_find_pattern(p, Qnil, get_value($:1)); %*/
+                    /*% ripper: ripper_new_find_pattern(p, Qnil, $:1) %*/
                     }
                 | p_args_tail
                     {
                         $$ = new_array_pattern(p, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, get_value($:1)); %*/
+                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, $:1) %*/
                     }
                 | p_kwargs
                     {
                         $$ = new_hash_pattern(p, 0, $1, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, get_value($:1)); %*/
+                    /*% ripper: ripper_new_hash_pattern(p, Qnil, $:1) %*/
                     }
                 ;
 
@@ -5628,14 +5607,14 @@ p_alt		: p_alt '|' p_expr_basic
 p_lparen	: '(' p_pktbl
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
 p_lbracket	: '[' p_pktbl
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
@@ -5646,70 +5625,70 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_array_pattern(p, $p_const, 0, $p_args, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, get_value($:p_const), Qnil, get_value($:p_args)); %*/
+                    /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, $:p_args) %*/
                     }
                 | p_const p_lparen[p_pktbl] p_find rparen
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_find_pattern(p, $p_const, $p_find, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_find_pattern(p, get_value($:p_const), get_value($:p_find)); %*/
+                    /*% ripper: ripper_new_find_pattern(p, $:p_const, $:p_find) %*/
                     }
                 | p_const p_lparen[p_pktbl] p_kwargs rparen
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_hash_pattern(p, $p_const, $p_kwargs, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_hash_pattern(p, get_value($:p_const), get_value($:p_kwargs)); %*/
+                    /*% ripper: ripper_new_hash_pattern(p, $:p_const, $:p_kwargs) %*/
                     }
                 | p_const '(' rparen
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, $p_const, 0, $$, &@$);
-                        /*% ripper: ripper_new_array_pattern(p, get_value($:p_const), Qnil, rb_ary_new()); %*/
+                        /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, rb_ary_new()) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_args rbracket
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_array_pattern(p, $p_const, 0, $p_args, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, get_value($:p_const), Qnil, get_value($:p_args)); %*/
+                    /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, $:p_args) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_find rbracket
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_find_pattern(p, $p_const, $p_find, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_find_pattern(p, get_value($:p_const), get_value($:p_find)); %*/
+                    /*% ripper: ripper_new_find_pattern(p, $:p_const, $:p_find) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_kwargs rbracket
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_hash_pattern(p, $p_const, $p_kwargs, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_hash_pattern(p, get_value($:p_const), get_value($:p_kwargs)); %*/
+                    /*% ripper: ripper_new_hash_pattern(p, $:p_const, $:p_kwargs) %*/
                     }
                 | p_const '[' rbracket
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, $1, 0, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, get_value($:1), Qnil, rb_ary_new()); %*/
+                    /*% ripper: ripper_new_array_pattern(p, $:1, Qnil, rb_ary_new()) %*/
                     }
                 | tLBRACK p_args rbracket
                     {
                         $$ = new_array_pattern(p, 0, 0, $p_args, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, get_value($:p_args)); %*/
+                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, $:p_args) %*/
                     }
                 | tLBRACK p_find rbracket
                     {
                         $$ = new_find_pattern(p, 0, $p_find, &@$);
-                    /*% ripper: ripper_new_find_pattern(p, Qnil, get_value($:p_find)); %*/
+                    /*% ripper: ripper_new_find_pattern(p, Qnil, $:p_find) %*/
                     }
                 | tLBRACK rbracket
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, 0, 0, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, rb_ary_new()); %*/
+                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, rb_ary_new()) %*/
                     }
                 | tLBRACE p_pktbl lex_ctxt[ctxt]
                     {
@@ -5720,24 +5699,19 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         p->ctxt.in_kwarg = $ctxt.in_kwarg;
                         $$ = new_hash_pattern(p, 0, $p_kwargs, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, get_value($:p_kwargs)); %*/
+                    /*% ripper: ripper_new_hash_pattern(p, Qnil, $:p_kwargs) %*/
                     }
                 | tLBRACE rbrace
                     {
                         $$ = new_hash_pattern_tail(p, 0, 0, &@$);
                         $$ = new_hash_pattern(p, 0, $$, &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE val = ripper_new_hash_pattern_tail(p, Qnil, 0);
-                        val = ripper_new_hash_pattern(p, Qnil, val);
-                        set_value(val);
-                    %*/
+                    /*% ripper: ripper_new_hash_pattern(p, Qnil, ripper_new_hash_pattern_tail(p, Qnil, 0)) %*/
                     }
                 | tLPAREN p_pktbl p_expr rparen
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = $p_expr;
-                    /*% ripper: get_value($:p_expr); %*/
+                    /*% ripper: $:p_expr %*/
                     }
                 ;
 
@@ -5745,44 +5719,28 @@ p_args		: p_expr
                     {
                         NODE *pre_args = NEW_LIST($1, &@$);
                         $$ = new_array_pattern_tail(p, pre_args, 0, 0, 0, &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE ary = rb_ary_new_from_args(1, get_value($:1));
-                        set_value(rb_ary_new_from_args(3, ary, Qnil, Qnil));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(1, $:1) %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:$, Qnil, Qnil) %*/
                     }
                 | p_args_head
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, 0, 0, &@$);
-                    /*%%%*/
-                    /*%
-                        set_value(rb_ary_new_from_args(3, get_value($:1), Qnil, Qnil));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, Qnil) %*/
                     }
                 | p_args_head p_arg
                     {
                         $$ = new_array_pattern_tail(p, list_concat($1, $2), 0, 0, 0, &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE pre_args = rb_ary_concat(get_value($:1), get_value($:2));
-                        set_value(rb_ary_new_from_args(3, pre_args, Qnil, Qnil));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(3, rb_ary_concat($:1, $:2), Qnil, Qnil) %*/
                     }
                 | p_args_head p_rest
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, $2, 0, &@$);
-                    /*%%%*/
-                    /*%
-                        set_value(rb_ary_new_from_args(3, get_value($:1), get_value($:2), Qnil));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, $:2, Qnil) %*/
                     }
                 | p_args_head p_rest ',' p_args_post
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, $2, $4, &@$);
-                    /*%%%*/
-                    /*%
-                        set_value(rb_ary_new_from_args(3, get_value($:1), get_value($:2), get_value($:4)));
-                    %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, $:2, $:4) %*/
                     }
                 | p_args_tail
                 ;
@@ -5794,26 +5752,26 @@ p_args_head	: p_arg ','
                 | p_args_head p_arg ','
                     {
                         $$ = list_concat($1, $2);
-                    /*% ripper: rb_ary_concat(get_value($:1), get_value($:2)) %*/
+                    /*% ripper: rb_ary_concat($:1, $:2) %*/
                     }
                 ;
 
 p_args_tail	: p_rest
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, $1, 0, &@$);
-                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, get_value($:1), Qnil); %*/
+                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, $:1, Qnil) %*/
                     }
                 | p_rest ',' p_args_post
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, $1, $3, &@$);
-                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, get_value($:1), get_value($:3)); %*/
+                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, $:1, $:3) %*/
                     }
                 ;
 
 p_find		: p_rest ',' p_args_post ',' p_rest
                     {
                         $$ = new_find_pattern_tail(p, $1, $3, $5, &@$);
-                    /*% ripper: ripper_new_find_pattern_tail(p, get_value($:1), get_value($:3), get_value($:5)) %*/
+                    /*% ripper: ripper_new_find_pattern_tail(p, $:1, $:3, $:5) %*/
                     }
                 ;
 
@@ -5822,12 +5780,12 @@ p_rest		: tSTAR tIDENTIFIER
                     {
                         error_duplicate_pattern_variable(p, $2, &@2);
                         $$ = assignable(p, $2, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $2, var_field(p, get_value($:2))) %*/
+                    /*% ripper: ripper_assignable(p, $2, var_field!($:2)) %*/
                     }
                 | tSTAR
                     {
                         $$ = 0;
-                    /*% ripper: var_field(p, Qnil) %*/
+                    /*% ripper: var_field!(Qnil) %*/
                     }
                 ;
 
@@ -5835,45 +5793,45 @@ p_args_post	: p_arg
                 | p_args_post ',' p_arg
                     {
                         $$ = list_concat($1, $3);
-                    /*% ripper: rb_ary_concat(get_value($:1), get_value($:3)) %*/
+                    /*% ripper: rb_ary_concat($:1, $:3) %*/
                     }
                 ;
 
 p_arg		: p_expr
                     {
                         $$ = NEW_LIST($1, &@$);
-                    /*% ripper: rb_ary_new_from_args(1, get_value($:1)) %*/
+                    /*% ripper: rb_ary_new_from_args(1, $:1) %*/
                     }
                 ;
 
 p_kwargs	: p_kwarg ',' p_any_kwrest
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), $3, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, get_value($:1), get_value($:3)) %*/
+                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, $:3) %*/
                     }
                 | p_kwarg
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), 0, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, get_value($:1), 0) %*/
+                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, 0) %*/
                     }
                 | p_kwarg ','
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), 0, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, get_value($:1), 0) %*/
+                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, 0) %*/
                     }
                 | p_any_kwrest
                     {
                         $$ =  new_hash_pattern_tail(p, new_hash(p, 0, &@$), $1, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, rb_ary_new(), get_value($:1)) %*/
+                    /*% ripper: ripper_new_hash_pattern_tail(p, rb_ary_new(), $:1) %*/
                     }
                 ;
 
 p_kwarg 	: p_kw
-                    /*% ripper[brace]: rb_ary_new_from_args(1, get_value($:1)) %*/
+                    /*% ripper[brace]: rb_ary_new_from_args(1, $:1) %*/
                 | p_kwarg ',' p_kw
                     {
                         $$ = list_concat($1, $3);
-                    /*% ripper: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                    /*% ripper: rb_ary_push($:1, $:3) %*/
                     }
                 ;
 
@@ -5881,7 +5839,7 @@ p_kw		: p_kw_label p_expr
                     {
                         error_duplicate_pattern_key(p, $1, &@1);
                         $$ = list_append(p, NEW_LIST(NEW_SYM(rb_id2str($1), &@1), &@$), $2);
-                    /*% ripper: rb_ary_new_from_args(2, get_value($:1), get_value($:2)) %*/
+                    /*% ripper: rb_ary_new_from_args(2, $:1, $:2) %*/
                     }
                 | p_kw_label
                     {
@@ -5891,7 +5849,7 @@ p_kw		: p_kw_label p_expr
                         }
                         error_duplicate_pattern_variable(p, $1, &@1);
                         $$ = list_append(p, NEW_LIST(NEW_SYM(rb_id2str($1), &@$), &@$), assignable(p, $1, 0, &@$));
-                    /*% ripper: rb_ary_new_from_args(2, ripper_assignable(p, $1, get_value($:1)), Qnil) %*/
+                    /*% ripper: rb_ary_new_from_args(2, ripper_assignable(p, $1, $:1), Qnil) %*/
                     }
                 ;
 
@@ -5907,19 +5865,19 @@ p_kw_label	: tLABEL
                             yyerror1(&loc, "symbol literal with interpolation is not allowed");
                             $$ = rb_intern_str(STR_NEW0());
                         }
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
 p_kwrest	: kwrest_mark tIDENTIFIER
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | kwrest_mark
                     {
                         $$ = 0;
-                    /*% ripper: 0; %*/
+                    /*% ripper: 0 %*/
                     }
                 ;
 
@@ -6001,7 +5959,7 @@ p_variable	: tIDENTIFIER
                     {
                         error_duplicate_pattern_variable(p, $1, &@1);
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
@@ -6076,7 +6034,7 @@ opt_rescue	: k_rescue exc_list exc_var then
 exc_list	: arg_value
                     {
                         $$ = NEW_LIST($1, &@$);
-                    /*% ripper: rb_ary_new3(1, get_value($:1)) %*/
+                    /*% ripper: rb_ary_new3(1, $:1) %*/
                     }
                 | mrhs
                     {
@@ -6088,7 +6046,7 @@ exc_list	: arg_value
 exc_var		: tASSOC lhs
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | none
                 ;
@@ -6116,7 +6074,7 @@ strings		: string
                             node = evstr2dstr(p, node);
                         }
                         $$ = node;
-                    /*% ripper: get_value($:1); %*/
+                    /*% ripper: $:1 %*/
                     }
                 ;
 
@@ -6131,32 +6089,26 @@ string		: tCHAR
 
 string1		: tSTRING_BEG string_contents tSTRING_END
                     {
-                    /*%%%*/
-                    /*%
-                        int indent = p->heredoc_indent;
-                    %*/
                         $$ = heredoc_dedent(p, $2);
                         if ($$) nd_set_loc($$, &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch1(string_literal, ripper_heredoc_dedent(p, indent, get_value($:2)));
-                        set_value(val);
-                    %*/
+                    /*% ripper: $:2 %*/
+                        if (p->heredoc_indent > 0) {
+                        /*% ripper: heredoc_dedent!($:$, INT2NUM(%{p->heredoc_indent})) %*/
+                            p->heredoc_indent = 0;
+                        }
+                    /*% ripper: string_literal!($:$) %*/
                     }
                 ;
 
 xstring		: tXSTRING_BEG xstring_contents tSTRING_END
                     {
-                    /*%%%*/
-                    /*%
-                        int indent = p->heredoc_indent;
-                    %*/
                         $$ = new_xstring(p, heredoc_dedent(p, $2), &@$);
-                    /*%%%*/
-                    /*%
-                        VALUE val = dispatch1(xstring_literal, ripper_heredoc_dedent(p, indent, get_value($:2)));
-                        set_value(val);
-                    %*/
+                    /*% ripper: $:2 %*/
+                        if (p->heredoc_indent > 0) {
+                        /*% ripper: heredoc_dedent!($:$, INT2NUM(%{p->heredoc_indent})) %*/
+                            p->heredoc_indent = 0;
+                        }
+                    /*% ripper: xstring_literal!($:$) %*/
                     }
                 ;
 
@@ -6294,7 +6246,7 @@ regexp_contents: /* none */
                 ;
 
 string_content	: tSTRING_CONTENT
-                    /*% ripper[brace]: get_value($:1); %*/
+                    /*% ripper[brace]: $:1 %*/
                 | tSTRING_DVAR
                     {
                         /* need to backup p->lex.strterm so that a string literal `%&foo,#$&,bar&` can be parsed */
@@ -6444,12 +6396,12 @@ var_ref		: user_variable
 var_lhs		: user_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field(p, get_value($:1))) %*/
+                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
@@ -6465,7 +6417,7 @@ superclass	: '<'
                   expr_value term
                     {
                         $$ = $3;
-                    /*% ripper: get_value($:3); %*/
+                    /*% ripper: $:3 %*/
                     }
                 | /* none */
                     {
@@ -6508,108 +6460,108 @@ f_arglist	: f_paren_args
                         $$ = $2;
                         SET_LEX_STATE(EXPR_BEG);
                         p->command_start = TRUE;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 ;
 
 args_tail	: f_kwarg(f_kw) ',' f_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, $3, $4, &@3);
-                    /*% ripper: rb_ary_new_from_args(3, get_value($:1), get_value($:3), get_value($:4)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, $:3, $:4) %*/
                     }
                 | f_kwarg(f_kw) opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, 0, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, get_value($:1), Qnil, get_value($:2)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, $:2) %*/
                     }
                 | f_any_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, 0, $1, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, get_value($:1), get_value($:2)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, $:2) %*/
                     }
                 | f_block_arg
                     {
                         $$ = new_args_tail(p, 0, 0, $1, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, get_value($:1)); %*/
+                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, $:1) %*/
                     }
                 | args_forward
                     {
                         add_forwarding_args(p);
                         $$ = new_args_tail(p, 0, $1, arg_FWD_BLOCK, &@1);
                         $$->nd_ainfo.forwarding = 1;
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, get_value($:1), Qnil); %*/
+                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, Qnil) %*/
                     }
                 ;
 
 f_args		: f_arg ',' f_optarg(arg_value) ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, 0, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), get_value($:5), Qnil, get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, Qnil, $:6) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, $7, $8, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), get_value($:5), get_value($:7), get_value($:8)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, $:7, $:8) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), Qnil, Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, Qnil, $:4) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), get_value($:3), Qnil, get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, $:5, $:6) %*/
                     }
                 | f_arg ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, get_value($:3), Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, Qnil, $:4) %*/
                     }
                 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, get_value($:3), get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, $:5, $:6) %*/
                     }
                 | f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, get_value($:1), Qnil, Qnil, Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, $:1, Qnil, Qnil, Qnil, $:2) %*/
                     }
                 | f_optarg(arg_value) ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), get_value($:3), Qnil, get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, Qnil, $:4) %*/
                     }
                 | f_optarg(arg_value) ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), get_value($:3), get_value($:5), get_value($:6)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, $:5, $:6) %*/
                     }
                 | f_optarg(arg_value) opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), Qnil, Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, Qnil, $:2) %*/
                     }
                 | f_optarg(arg_value) ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, get_value($:1), Qnil, get_value($:3), get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, $:3, $:4) %*/
                     }
                 | f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, get_value($:1), Qnil, get_value($:2)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, Qnil, $:2) %*/
                     }
                 | f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, get_value($:1), get_value($:3), get_value($:4)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, $:3, $:4) %*/
                     }
                 | args_tail
                     {
                         $$ = new_args(p, 0, 0, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, get_value($:1)) %*/
+                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, $:1) %*/
                     }
                 | /* none */
                     {
@@ -6674,10 +6626,7 @@ f_norm_arg	: f_bad_arg
                         formal_argument(p, $1);
                         p->max_numparam = ORDINAL_PARAM;
                         $$ = $1;
-                    /*%%%*/
-                    /*%
-                        ripper_formal_argument(p, $1, get_value($:1));
-                    %*/
+                    /*% ripper: ripper_formal_argument(p, $1, $:1) %*/
                     }
                 ;
 
@@ -6694,7 +6643,7 @@ f_arg_item	: f_arg_asgn
                     {
                         p->cur_arg = 0;
                         $$ = NEW_ARGS_AUX($1, 1, &NULL_LOC);
-                    /*% ripper: get_value($:1) %*/
+                    /*% ripper: $:1 %*/
                     }
                 | tLPAREN f_margs rparen
                     {
@@ -6716,14 +6665,14 @@ f_arg_item	: f_arg_asgn
                 ;
 
 f_arg		: f_arg_item
-                    /*% ripper[brace]: rb_ary_new3(1, get_value($:1)) %*/
+                    /*% ripper[brace]: rb_ary_new3(1, $:1) %*/
                 | f_arg ',' f_arg_item
                     {
                         $$ = $1;
                         $$->nd_plen++;
                         $$->nd_next = block_append(p, $$->nd_next, $3->nd_next);
                         rb_discard_node(p, (NODE *)$3);
-                    /*% ripper: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                    /*% ripper: rb_ary_push($:1, $:3) %*/
                     }
                 ;
 
@@ -6735,10 +6684,7 @@ f_label 	: tLABEL
                         p->max_numparam = ORDINAL_PARAM;
                         p->ctxt.in_argdef = 0;
                         $$ = $1;
-                    /*%%%*/
-                    /*%
-                        ripper_formal_argument(p, $1, get_value($:1));
-                    %*/
+                    /*% ripper: ripper_formal_argument(p, $1, $:1) %*/
                     }
                 ;
 
@@ -6747,14 +6693,14 @@ f_kw		: f_label arg_value
                         p->cur_arg = 0;
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, $2, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, get_value($:1)), get_value($:2)) %*/
+                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:2) %*/
                     }
                 | f_label
                     {
                         p->cur_arg = 0;
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, NODE_SPECIAL_REQUIRED_KEYWORD, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, get_value($:1)), 0) %*/
+                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), 0) %*/
                     }
                 ;
 
@@ -6762,13 +6708,13 @@ f_block_kw	: f_label primary_value
                     {
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, $2, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, get_value($:1)), get_value($:2)) %*/
+                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:2) %*/
                     }
                 | f_label
                     {
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, NODE_SPECIAL_REQUIRED_KEYWORD, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, get_value($:1)), 0) %*/
+                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), 0) %*/
                     }
                 ;
 
@@ -6835,12 +6781,12 @@ f_block_arg	: blkarg_mark tIDENTIFIER
 opt_f_block_arg	: ',' f_block_arg
                     {
                         $$ = $2;
-                    /*% ripper: get_value($:2); %*/
+                    /*% ripper: $:2 %*/
                     }
                 | none
                     {
                         $$ = 0;
-                    /*% ripper: Qnil; %*/
+                    /*% ripper: Qnil %*/
                     }
                 ;
 
@@ -6890,7 +6836,7 @@ assoc_list	: none
                 ;
 
 assocs		: assoc
-                    /*% ripper[brace]: rb_ary_new3(1, get_value($:1)) %*/
+                    /*% ripper[brace]: rb_ary_new3(1, $:1) %*/
                 | assocs ',' assoc
                     {
                         NODE *assocs = $1;
@@ -6912,7 +6858,7 @@ assocs		: assoc
                             }
                         }
                         $$ = assocs;
-                    /*% ripper: rb_ary_push(get_value($:1), get_value($:3)) %*/
+                    /*% ripper: rb_ary_push($:1, $:3) %*/
                     }
                 ;
 
@@ -9106,7 +9052,6 @@ heredoc_dedent(struct parser_params *p, NODE *root)
     rb_parser_string_t *prev_lit = 0;
 
     if (indent <= 0) return root;
-    p->heredoc_indent = 0;
     if (!root) return root;
 
     prev_node = node = str_node = root;
@@ -9150,17 +9095,6 @@ heredoc_dedent(struct parser_params *p, NODE *root)
     return root;
 }
 
-#ifdef RIPPER
-static VALUE
-ripper_heredoc_dedent(struct parser_params *p, int indent, VALUE array)
-{
-    if (indent <= 0) return array;
-    p->heredoc_indent = 0;
-    dispatch2(heredoc_dedent, array, INT2NUM(indent));
-    return array;
-}
-#endif
-
 static int
 whole_match_p(struct parser_params *p, const char *eos, long len, int indent)
 {
@@ -9526,7 +9460,7 @@ formal_argument(struct parser_params *p, ID id)
 }
 
 #ifdef RIPPER
-static void
+static VALUE
 ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs)
 {
     switch (id_type(id)) {
@@ -9535,21 +9469,22 @@ ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs)
 #define ERR(mesg) (dispatch2(param_error, WARN_S(mesg), lhs), ripper_error(p))
       case ID_CONST:
         ERR("formal argument cannot be a constant");
-        return;
+        break;
       case ID_INSTANCE:
         ERR("formal argument cannot be an instance variable");
-        return;
+        break;
       case ID_GLOBAL:
         ERR("formal argument cannot be a global variable");
-        return;
+        break;
       case ID_CLASS:
         ERR("formal argument cannot be a class variable");
-        return;
+        break;
       default:
         ERR("formal argument must be local variable");
-        return;
+        break;
 #undef ERR
     }
+    return lhs;
 }
 #endif
 
@@ -15064,12 +14999,6 @@ assign_error(struct parser_params *p, const char *mesg, VALUE a)
     ripper_error(p);
     return a;
 }
-
-static VALUE
-var_field(struct parser_params *p, VALUE a)
-{
-    return dispatch1(var_field, a);
-}
 #endif
 
 static NODE *

From 2e765c20dbd542d43155749910421b0f7963524f Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Fri, 10 May 2024 23:08:25 +0900
Subject: [PATCH 121/242] ripper: Short hand for `rb_ary_new_from_args`

---
 ext/ripper/tools/dsl.rb | 14 ++++++-
 parse.y                 | 93 +++++++++++++++--------------------------
 2 files changed, 47 insertions(+), 60 deletions(-)

diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index d090b15c0bf3b2..68641f4da7e1ea 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -26,6 +26,18 @@ def self.line?(line, lineno = nil)
     end
   end
 
+  using Module.new {
+    refine Array do
+      def to_s
+        if empty?
+          "rb_ary_new()"
+        else
+          "rb_ary_new_from_args(#{size}, #{map(&:to_s).join(', ')})"
+        end
+      end
+    end
+  }
+
   def initialize(code, options, lineno = nil)
     @lineno = lineno
     @events = {}
@@ -100,7 +112,7 @@ def method_missing(event, *args)
     elsif args.empty? and /\Aid[A-Z_]/ =~ event.to_s
       event
     else
-      "#{ event }(#{ args.join(", ") })"
+      "#{ event }(#{ args.map(&:to_s).join(", ") })"
     end
   end
 
diff --git a/parse.y b/parse.y
index 4f295eb12fef4e..7a679435675120 100644
--- a/parse.y
+++ b/parse.y
@@ -1638,12 +1638,6 @@ ripper_new_array_pattern(struct parser_params *p, VALUE constant, VALUE pre_arg,
     return dispatch4(aryptn, constant, pre_args, rest_arg, post_args);
 }
 
-static VALUE
-ripper_new_array_pattern_tail(struct parser_params *p, VALUE pre_args, VALUE rest_arg, VALUE post_args)
-{
-    return rb_ary_new_from_args(3, pre_args, rest_arg, post_args);
-}
-
 static VALUE
 ripper_new_hash_pattern(struct parser_params *p, VALUE constant, VALUE hshptn)
 {
@@ -1653,18 +1647,6 @@ ripper_new_hash_pattern(struct parser_params *p, VALUE constant, VALUE hshptn)
     return dispatch3(hshptn, constant, kw_args, kw_rest_arg);
 }
 
-static VALUE
-ripper_new_hash_pattern_tail(struct parser_params *p, VALUE kw_args, VALUE kw_rest_arg)
-{
-    if (kw_rest_arg) {
-        kw_rest_arg = dispatch1(var_field, kw_rest_arg);
-    }
-    else {
-        kw_rest_arg = Qnil;
-    }
-    return rb_ary_new_from_args(2, kw_args, kw_rest_arg);
-}
-
 static VALUE
 ripper_new_find_pattern(struct parser_params *p, VALUE constant, VALUE fndptn)
 {
@@ -1675,12 +1657,6 @@ ripper_new_find_pattern(struct parser_params *p, VALUE constant, VALUE fndptn)
     return dispatch4(fndptn, constant, pre_rest_arg, args, post_rest_arg);
 }
 
-static VALUE
-ripper_new_find_pattern_tail(struct parser_params *p, VALUE pre_rest_arg, VALUE args, VALUE post_rest_arg)
-{
-    return rb_ary_new_from_args(3, pre_rest_arg, args, post_rest_arg);
-}
-
 #define ID2VAL(id) STATIC_ID2SYM(id)
 #define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
 #endif /* RIPPER */
@@ -3024,7 +3000,7 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
                                     | /* none */
                                         {
                                             $$ = new_args_tail(p, 0, 0, 0, &@0);
-                                        /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, Qnil) %*/
+                                        /*% ripper: [Qnil, Qnil, Qnil] %*/
                                         }
                                     ;
 
@@ -3490,7 +3466,7 @@ defs_head	: k_def singleton dot_or_colon
                         $$ = def_head_save(p, $k_def);
                         $$->nd_mid = $def_name;
                         $$->nd_def = NEW_DEFS($singleton, $def_name, 0, &@$);
-                    /*% ripper: rb_ary_new_from_args(3, $:singleton, $:dot_or_colon, $:def_name) %*/
+                    /*% ripper: [$:singleton, $:dot_or_colon, $:def_name] %*/
                     }
                 ;
 
@@ -5082,22 +5058,22 @@ f_eq		: {p->ctxt.in_argdef = 0;} '=';
 block_args_tail	: f_kwarg(f_block_kw) ',' f_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, $3, $4, &@3);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, $:3, $:4) %*/
+                    /*% ripper: [$:1, $:3, $:4] %*/
                     }
                 | f_kwarg(f_block_kw) opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, 0, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, $:2) %*/
+                    /*% ripper: [$:1, Qnil, $:2] %*/
                     }
                 | f_any_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, 0, $1, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, $:2) %*/
+                    /*% ripper: [Qnil, $:1, $:2] %*/
                     }
                 | f_block_arg
                     {
                         $$ = new_args_tail(p, 0, 0, $1, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, $:1) %*/
+                    /*% ripper: [Qnil, Qnil, $:1] %*/
                     }
                 ;
 
@@ -5138,7 +5114,7 @@ block_param	: f_arg ',' f_optarg(primary_value) ',' f_rest_arg opt_args_tail(blo
                     {
                         $$ = new_args_tail(p, 0, 0, 0, &@2);
                         $$ = new_args(p, $1, 0, $2, 0, $$, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:2, Qnil, rb_ary_new_from_args(3, Qnil, Qnil, Qnil)) %*/
+                    /*% ripper: params!($:1, Qnil, $:2, Qnil, Qnil, Qnil, Qnil) %*/
                     }
                 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
@@ -5705,7 +5681,7 @@ p_expr_basic	: p_value
                     {
                         $$ = new_hash_pattern_tail(p, 0, 0, &@$);
                         $$ = new_hash_pattern(p, 0, $$, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, ripper_new_hash_pattern_tail(p, Qnil, 0)) %*/
+                    /*% ripper: ripper_new_hash_pattern(p, Qnil, [Qnil, Qnil]) %*/
                     }
                 | tLPAREN p_pktbl p_expr rparen
                     {
@@ -5719,28 +5695,27 @@ p_args		: p_expr
                     {
                         NODE *pre_args = NEW_LIST($1, &@$);
                         $$ = new_array_pattern_tail(p, pre_args, 0, 0, 0, &@$);
-                    /*% ripper: rb_ary_new_from_args(1, $:1) %*/
-                    /*% ripper: rb_ary_new_from_args(3, $:$, Qnil, Qnil) %*/
+                    /*% ripper: [[$:1], Qnil, Qnil] %*/
                     }
                 | p_args_head
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, 0, 0, &@$);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, Qnil) %*/
+                    /*% ripper: [$:1, Qnil, Qnil] %*/
                     }
                 | p_args_head p_arg
                     {
                         $$ = new_array_pattern_tail(p, list_concat($1, $2), 0, 0, 0, &@$);
-                    /*% ripper: rb_ary_new_from_args(3, rb_ary_concat($:1, $:2), Qnil, Qnil) %*/
+                    /*% ripper: [rb_ary_concat($:1, $:2), Qnil, Qnil] %*/
                     }
                 | p_args_head p_rest
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, $2, 0, &@$);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, $:2, Qnil) %*/
+                    /*% ripper: [$:1, $:2, Qnil] %*/
                     }
                 | p_args_head p_rest ',' p_args_post
                     {
                         $$ = new_array_pattern_tail(p, $1, 1, $2, $4, &@$);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, $:2, $:4) %*/
+                    /*% ripper: [$:1, $:2, $:4] %*/
                     }
                 | p_args_tail
                 ;
@@ -5759,19 +5734,19 @@ p_args_head	: p_arg ','
 p_args_tail	: p_rest
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, $1, 0, &@$);
-                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, $:1, Qnil) %*/
+                    /*% ripper: [Qnil, $:1, Qnil] %*/
                     }
                 | p_rest ',' p_args_post
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, $1, $3, &@$);
-                    /*% ripper: ripper_new_array_pattern_tail(p, Qnil, $:1, $:3) %*/
+                    /*% ripper: [Qnil, $:1, $:3] %*/
                     }
                 ;
 
 p_find		: p_rest ',' p_args_post ',' p_rest
                     {
                         $$ = new_find_pattern_tail(p, $1, $3, $5, &@$);
-                    /*% ripper: ripper_new_find_pattern_tail(p, $:1, $:3, $:5) %*/
+                    /*% ripper: [$:1, $:3, $:5] %*/
                     }
                 ;
 
@@ -5800,34 +5775,34 @@ p_args_post	: p_arg
 p_arg		: p_expr
                     {
                         $$ = NEW_LIST($1, &@$);
-                    /*% ripper: rb_ary_new_from_args(1, $:1) %*/
+                    /*% ripper: [$:1] %*/
                     }
                 ;
 
 p_kwargs	: p_kwarg ',' p_any_kwrest
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), $3, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, $:3) %*/
+                    /*% ripper: [$:1, $:3] %*/
                     }
                 | p_kwarg
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), 0, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, 0) %*/
+                    /*% ripper: [$:1, Qnil] %*/
                     }
                 | p_kwarg ','
                     {
                         $$ =  new_hash_pattern_tail(p, new_unique_key_hash(p, $1, &@$), 0, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, $:1, 0) %*/
+                    /*% ripper: [$:1, Qnil] %*/
                     }
                 | p_any_kwrest
                     {
                         $$ =  new_hash_pattern_tail(p, new_hash(p, 0, &@$), $1, &@$);
-                    /*% ripper: ripper_new_hash_pattern_tail(p, rb_ary_new(), $:1) %*/
+                    /*% ripper: [[], $:1] %*/
                     }
                 ;
 
 p_kwarg 	: p_kw
-                    /*% ripper[brace]: rb_ary_new_from_args(1, $:1) %*/
+                    /*% ripper[brace]: [$:1] %*/
                 | p_kwarg ',' p_kw
                     {
                         $$ = list_concat($1, $3);
@@ -5839,7 +5814,7 @@ p_kw		: p_kw_label p_expr
                     {
                         error_duplicate_pattern_key(p, $1, &@1);
                         $$ = list_append(p, NEW_LIST(NEW_SYM(rb_id2str($1), &@1), &@$), $2);
-                    /*% ripper: rb_ary_new_from_args(2, $:1, $:2) %*/
+                    /*% ripper: [$:1, $:2] %*/
                     }
                 | p_kw_label
                     {
@@ -5849,7 +5824,7 @@ p_kw		: p_kw_label p_expr
                         }
                         error_duplicate_pattern_variable(p, $1, &@1);
                         $$ = list_append(p, NEW_LIST(NEW_SYM(rb_id2str($1), &@$), &@$), assignable(p, $1, 0, &@$));
-                    /*% ripper: rb_ary_new_from_args(2, ripper_assignable(p, $1, $:1), Qnil) %*/
+                    /*% ripper: [ripper_assignable(p, $1, $:1), Qnil] %*/
                     }
                 ;
 
@@ -5872,12 +5847,12 @@ p_kw_label	: tLABEL
 p_kwrest	: kwrest_mark tIDENTIFIER
                     {
                         $$ = $2;
-                    /*% ripper: $:2 %*/
+                    /*% ripper: var_field!($:2) %*/
                     }
                 | kwrest_mark
                     {
                         $$ = 0;
-                    /*% ripper: 0 %*/
+                    /*% ripper: Qnil %*/
                     }
                 ;
 
@@ -5891,7 +5866,7 @@ p_any_kwrest	: p_kwrest
                 | p_kwnorest
                     {
                         $$ = idNil;
-                    /*% ripper: ID2VAL(idNil) %*/
+                    /*% ripper: var_field!(ID2VAL(idNil)) %*/
                     }
                 ;
 
@@ -6432,7 +6407,7 @@ f_opt_paren_args: f_paren_args
                         p->ctxt.in_argdef = 0;
                         $$ = new_args_tail(p, 0, 0, 0, &@0);
                         $$ = new_args(p, 0, 0, 0, 0, $$, &@0);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, rb_ary_new_from_args(3, Qnil, Qnil, Qnil)) %*/
+                    /*% ripper: params!(Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil) %*/
                     }
                 ;
 
@@ -6467,29 +6442,29 @@ f_arglist	: f_paren_args
 args_tail	: f_kwarg(f_kw) ',' f_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, $3, $4, &@3);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, $:3, $:4) %*/
+                    /*% ripper: [$:1, $:3, $:4] %*/
                     }
                 | f_kwarg(f_kw) opt_f_block_arg
                     {
                         $$ = new_args_tail(p, $1, 0, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, $:1, Qnil, $:2) %*/
+                    /*% ripper: [$:1, Qnil, $:2] %*/
                     }
                 | f_any_kwrest opt_f_block_arg
                     {
                         $$ = new_args_tail(p, 0, $1, $2, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, $:2) %*/
+                    /*% ripper: [Qnil, $:1, $:2] %*/
                     }
                 | f_block_arg
                     {
                         $$ = new_args_tail(p, 0, 0, $1, &@1);
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, Qnil, $:1) %*/
+                    /*% ripper: [Qnil, Qnil, $:1] %*/
                     }
                 | args_forward
                     {
                         add_forwarding_args(p);
                         $$ = new_args_tail(p, 0, $1, arg_FWD_BLOCK, &@1);
                         $$->nd_ainfo.forwarding = 1;
-                    /*% ripper: rb_ary_new_from_args(3, Qnil, $:1, Qnil) %*/
+                    /*% ripper: [Qnil, $:1, Qnil] %*/
                     }
                 ;
 
@@ -6567,7 +6542,7 @@ f_args		: f_arg ',' f_optarg(arg_value) ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args_tail(p, 0, 0, 0, &@0);
                         $$ = new_args(p, 0, 0, 0, 0, $$, &@0);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, rb_ary_new_from_args(3, Qnil, Qnil, Qnil)) %*/
+                    /*% ripper: params!(Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil) %*/
                     }
                 ;
 

From ee8bbbabe549d1ff8a37509e3a5dc9e648aced3a Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 11:34:01 +0900
Subject: [PATCH 122/242] ripper: Show popped TOS in debug mode

---
 parse.y | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/parse.y b/parse.y
index 7a679435675120..b467c4a15488c9 100644
--- a/parse.y
+++ b/parse.y
@@ -634,10 +634,10 @@ static void
 after_reduce(int len, struct parser_params *p)
 {
     for (int i = 0; i < len; i++) {
+        VALUE tos = rb_ary_pop(p->s_value_stack);
         if (p->debug) {
-            rb_parser_printf(p, "after-reduce pop: %+"PRIsVALUE"\n", rb_ary_entry(p->s_value_stack, -1));
+            rb_parser_printf(p, "after-reduce pop: %+"PRIsVALUE"\n", tos);
         }
-        rb_ary_pop(p->s_value_stack);
     }
     if (p->debug) {
         rb_parser_printf(p, "after-reduce push: %+"PRIsVALUE"\n", p->s_lvalue);
@@ -659,10 +659,10 @@ static void
 after_pop_stack(int len, struct parser_params *p)
 {
     for (int i = 0; i < len; i++) {
+        VALUE tos = rb_ary_pop(p->s_value_stack);
         if (p->debug) {
-            rb_parser_printf(p, "after-pop-stack pop: %+"PRIsVALUE"\n", rb_ary_entry(p->s_value_stack, -1));
+            rb_parser_printf(p, "after-pop-stack pop: %+"PRIsVALUE"\n", tos);
         }
-        rb_ary_pop(p->s_value_stack);
     }
 }
 #else

From 147134b474fc74b68537750a2f63c81a87bd0e86 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 11:44:45 +0900
Subject: [PATCH 123/242] ripper: Remove rb_ripper_none

Now it is used only for wheter `opt_paren_args` is `none`.  Introduce
a new special node to distinguish an empty parentheses from it .
---
 ext/ripper/ripper_init.c.tmpl |  4 ----
 ext/ripper/ripper_init.h      |  1 -
 ext/ripper/tools/dsl.rb       |  7 +------
 parse.y                       | 36 +++++++++++++++++++++++++----------
 4 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/ext/ripper/ripper_init.c.tmpl b/ext/ripper/ripper_init.c.tmpl
index 21f29bd79a80f1..fc98c067b87f21 100644
--- a/ext/ripper/ripper_init.c.tmpl
+++ b/ext/ripper/ripper_init.c.tmpl
@@ -665,8 +665,4 @@ InitVM_ripper(void)
      */
     rb_define_global_const("SCRIPT_LINES__", Qnil);
 #endif
-    rb_ripper_none = rb_obj_alloc(rb_cObject);
-    rb_obj_freeze(rb_ripper_none);
-    rb_gc_register_mark_object(rb_ripper_none);
-
 }
diff --git a/ext/ripper/ripper_init.h b/ext/ripper/ripper_init.h
index 664bb7bce368fc..9d228107d1b172 100644
--- a/ext/ripper/ripper_init.h
+++ b/ext/ripper/ripper_init.h
@@ -1,7 +1,6 @@
 #ifndef RIPPER_INIT_H
 #define RIPPER_INIT_H
 
-extern VALUE rb_ripper_none;
 PRINTF_ARGS(void ripper_compile_error(struct parser_params*, const char *fmt, ...), 2, 3);
 
 #endif /* RIPPER_INIT_H */
diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index 68641f4da7e1ea..5ef1d693188143 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -87,11 +87,7 @@ def new_var
     "v#{ @vars += 1 }"
   end
 
-  def opt_event(event, default, addend)
-    add_event(event, [default, addend], true)
-  end
-
-  def add_event(event, args, qundef_check = false)
+  def add_event(event, args)
     event = event.to_s.sub(/!\z/, "")
     @events[event] = args.size
     vars = []
@@ -101,7 +97,6 @@ def add_event(event, args, qundef_check = false)
     end
     v = new_var
     d = "dispatch#{ args.size }(#{ [event, *vars].join(",") })"
-    d = "#{ vars.last }==rb_ripper_none ? #{ vars.first } : #{ d }" if qundef_check
     @code << "#{ v }=#{ d };"
     v
   end
diff --git a/parse.y b/parse.y
index b467c4a15488c9..3e6be1db2c47da 100644
--- a/parse.y
+++ b/parse.y
@@ -83,6 +83,9 @@ static NODE *reg_named_capture_assign(struct parser_params* p, VALUE regexp, con
 #define compile_callback rb_suppress_tracing
 #endif /* !UNIVERSAL_PARSER */
 
+#define NODE_SPECIAL_EMPTY_ARGS ((NODE *)-1)
+#define NODE_EMPTY_ARGS_P(node) ((node) == NODE_SPECIAL_EMPTY_ARGS)
+
 static int rb_parser_string_hash_cmp(rb_parser_string_t *str1, rb_parser_string_t *str2);
 static rb_parser_string_t *rb_parser_string_deep_copy(struct parser_params *p, const rb_parser_string_t *original);
 
@@ -294,7 +297,6 @@ parse_isxdigit(int c)
 #define STRNCASECMP rb_parser_st_locale_insensitive_strncasecmp
 
 #ifdef RIPPER
-VALUE rb_ripper_none;
 #include "ripper_init.h"
 #endif
 
@@ -4268,13 +4270,16 @@ paren_args	: '(' opt_call_args rparen
 
 opt_paren_args	: none
                 | paren_args
+                    {
+                        $$ = $1 ? $1 : NODE_SPECIAL_EMPTY_ARGS;
+                    }
                 ;
 
 opt_call_args	: none
                 | call_args
                 | args ','
                     {
-                      $$ = $1;
+                        $$ = $1;
                     }
                 | args ',' assocs ','
                     {
@@ -5324,13 +5329,23 @@ block_call	: command do_block
                     }
                 | block_call call_op2 operation2 opt_paren_args
                     {
+                        bool has_args = $4 != 0;
+                        if (NODE_EMPTY_ARGS_P($4)) $4 = 0;
                         $$ = new_qcall(p, $2, $1, $3, $4, &@3, &@$);
-                    /*% ripper: opt_event(:method_add_arg!, call!($:1, $:2, $:3), $:4) %*/
+                    /*% ripper: call!($:1, $:2, $:3) %*/
+                        if (has_args) {
+                        /*% ripper: method_add_arg!($:$, $:4) %*/
+                        }
                     }
                 | block_call call_op2 operation2 opt_paren_args brace_block
                     {
+                        bool has_args = $5 != 0;
+                        if (NODE_EMPTY_ARGS_P($5)) $5 = 0;
                         $$ = new_command_qcall(p, $2, $1, $3, $4, $5, &@3, &@$);
-                    /*% ripper: opt_event(:method_add_block!, command_call!($:1, $:2, $:3, $:4), $:5) %*/
+                    /*% ripper: command_call!($:1, $:2, $:3, $:4) %*/
+                        if (has_args) {
+                        /*% ripper: method_add_block!($:$, $:5) %*/
+                        }
                     }
                 | block_call call_op2 operation2 command_args do_block
                     {
@@ -5348,9 +5363,14 @@ method_call	: fcall paren_args
                     }
                 | primary_value call_op operation2 opt_paren_args
                     {
+                        bool has_args = $4 != 0;
+                        if (NODE_EMPTY_ARGS_P($4)) $4 = 0;
                         $$ = new_qcall(p, $2, $1, $3, $4, &@3, &@$);
                         nd_set_line($$, @3.end_pos.lineno);
-                    /*% ripper: opt_event(:method_add_arg!, call!($:1, $:2, $:3), $:4) %*/
+                    /*% ripper: call!($:1, $:2, $:3) %*/
+                        if (has_args) {
+                        /*% ripper: method_add_arg!($:$, $:4) %*/
+                        }
                     }
                 | primary_value tCOLON2 operation2 paren_args
                     {
@@ -6928,10 +6948,6 @@ terms		: term
 none		: /* none */
                     {
                         $$ = 0;
-                    /*%%%*/
-                    /*%
-                        set_value(rb_ripper_none);
-                    %*/
                     }
                 ;
 %%
@@ -16160,7 +16176,7 @@ rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
 #endif
 
 #ifdef RIPPER
-#define validate(x) ((x) = (x) == rb_ripper_none ? Qnil : x)
+#define validate(x) (void)(x)
 
 static VALUE
 ripper_dispatch0(struct parser_params *p, ID mid)

From 47efdae6028e39bbe8f35d325e26e6bc206251ef Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 11:59:44 +0900
Subject: [PATCH 124/242] ripper: Preserve indentation

---
 ext/ripper/tools/dsl.rb     | 11 ++++++-----
 ext/ripper/tools/preproc.rb |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index 5ef1d693188143..4815364c9290f9 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -20,9 +20,9 @@ class DSL
   NAME_PATTERN = /(?>\$|\d+|[a-zA-Z_][a-zA-Z0-9_]*|\[[a-zA-Z_.][-a-zA-Z0-9_.]*\])(?>(?:\.|->)[a-zA-Z_][a-zA-Z0-9_]*)*/.source
   NOT_REF_PATTERN = /(?>\#.*|[^\"$@]*|"(?>\\.|[^\"])*")/.source
 
-  def self.line?(line, lineno = nil)
-    if %r</\*% *ripper(?:\[(.*?)\])?: *(.*?) *%\*/> =~ line
-      new($2, $1&.split(",") || [], lineno)
+  def self.line?(line, lineno = nil, indent: nil)
+    if %r<(?<space>\s*)/\*% *ripper(?:\[(?<option>.*?)\])?: *(?<code>.*?) *%\*/> =~ line
+      new(code, option&.split(",") || [], lineno, indent: indent || space)
     end
   end
 
@@ -38,8 +38,9 @@ def to_s
     end
   }
 
-  def initialize(code, options, lineno = nil)
+  def initialize(code, options, lineno = nil, indent: "\t\t\t")
     @lineno = lineno
+    @indent = indent
     @events = {}
     @error = options.include?("error")
     @brace = options.include?("brace")
@@ -80,7 +81,7 @@ def generate
     s = "{VALUE #{ (1..@vars).map {|v| "v#{ v }" }.join(",") };#{ s }}" if @vars > 0
     s << "ripper_error(p);" if @error
     s = "{#{ s }}" if @brace
-    "\t\t\t#{s}"
+    "#{@indent}#{s}"
   end
 
   def new_var
diff --git a/ext/ripper/tools/preproc.rb b/ext/ripper/tools/preproc.rb
index a92be93d5b976f..5e8a6e0cb58bb8 100644
--- a/ext/ripper/tools/preproc.rb
+++ b/ext/ripper/tools/preproc.rb
@@ -56,7 +56,7 @@ def process(f, out, path, template)
 def generate_line(f, out)
   while line = f.gets
     case
-    when gen = DSL.line?(line)
+    when gen = DSL.line?(line, f.lineno)
       out << gen.generate << "\n"
     when line.start_with?("%%")
       out << "%%\n"

From 66446b94358a78ddd168e5ce0b5ac475bb34ec50 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 18:52:26 +0900
Subject: [PATCH 125/242] ripper: Allow parenthesized comma in options

---
 ext/ripper/tools/dsl.rb | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index 4815364c9290f9..b55952cbeec9ec 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -22,10 +22,15 @@ class DSL
 
   def self.line?(line, lineno = nil, indent: nil)
     if %r<(?<space>\s*)/\*% *ripper(?:\[(?<option>.*?)\])?: *(?<code>.*?) *%\*/> =~ line
-      new(code, option&.split(",") || [], lineno, indent: indent || space)
+      new(code, comma_split(option), lineno, indent: indent || space)
     end
   end
 
+  def self.comma_split(str)
+    str or return []
+    str.scan(/(([^(,)]+|\((?:,|\g<0>)*\))+)/).map(&:first)
+  end
+
   using Module.new {
     refine Array do
       def to_s

From e61e5c3b84221880e71f85bfeeedcbed9bf907b5 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 19:04:25 +0900
Subject: [PATCH 126/242] ripper: Move `assign_error` call to `const_decl`

Prepare `path` as `$:$` before `const_decl` and update it there.
Remove `ripper_const_decl` which is no longer used.
---
 parse.y | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/parse.y b/parse.y
index 3e6be1db2c47da..15b172b4fca90b 100644
--- a/parse.y
+++ b/parse.y
@@ -1495,7 +1495,6 @@ static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYP
 static VALUE defs(struct parser_params *p, VALUE head, VALUE args, VALUE bodystmt);
 static VALUE backref_error(struct parser_params*, NODE *, VALUE);
 static VALUE ripper_assignable(struct parser_params *p, ID id, VALUE lhs);
-static VALUE ripper_const_decl(struct parser_params *p, VALUE path);
 static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
 static int id_is_var(struct parser_params *p, ID id);
 #endif
@@ -3726,13 +3725,13 @@ mlhs_node	: user_variable
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
+                    /*% ripper: const_path_field!($:1, $:3) %*/
                         $$ = const_decl(p, NEW_COLON2($1, $3, &@$), &@$);
-                    /*% ripper: ripper_const_decl(p, const_path_field!($:1, $:3)) %*/
                     }
                 | tCOLON3 tCONSTANT
                     {
+                    /*% ripper: top_const_field!($:2) %*/
                         $$ = const_decl(p, NEW_COLON3($2, &@$), &@$);
-                    /*% ripper: ripper_const_decl(p, top_const_field!($:2)) %*/
                     }
                 | backref
                     {
@@ -3776,13 +3775,13 @@ lhs		: user_variable
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
+                    /*% ripper: const_path_field!($:1, $:3) %*/
                         $$ = const_decl(p, NEW_COLON2($1, $3, &@$), &@$);
-                    /*% ripper: ripper_const_decl(p, const_path_field!($:1, $:3)) %*/
                     }
                 | tCOLON3 tCONSTANT
                     {
+                    /*% ripper: top_const_field!($:2) %*/
                         $$ = const_decl(p, NEW_COLON3($2, &@$), &@$);
-                    /*% ripper: ripper_const_decl(p, top_const_field!($:2)) %*/
                     }
                 | backref
                     {
@@ -14969,20 +14968,16 @@ static NODE *
 const_decl(struct parser_params *p, NODE *path, const YYLTYPE *loc)
 {
     if (p->ctxt.in_def) {
+#ifndef RIPPER
         yyerror1(loc, "dynamic constant assignment");
+#else
+        set_value(assign_error(p, "dynamic constant assignment", p->s_lvalue));
+#endif
     }
     return NEW_CDECL(0, 0, (path), p->ctxt.shareable_constant_value, loc);
 }
-#ifdef RIPPER
-static VALUE
-ripper_const_decl(struct parser_params *p, VALUE path)
-{
-    if (p->ctxt.in_def) {
-        path = assign_error(p, "dynamic constant assignment", path);
-    }
-    return path;
-}
 
+#ifdef RIPPER
 static VALUE
 assign_error(struct parser_params *p, const char *mesg, VALUE a)
 {

From 56d2c26c85a527d6cdf95a78ad7f442ea9cb0e7b Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 19:17:15 +0900
Subject: [PATCH 127/242] ripper: Move `assign_error` call to `assignable`

Prepare `lhs` as `$:$` before `assignable` and update it there.
Remove `ripper_assignable` which is no longer used.
---
 parse.y | 44 +++++++++++++++++---------------------------
 1 file changed, 17 insertions(+), 27 deletions(-)

diff --git a/parse.y b/parse.y
index 15b172b4fca90b..9057f90fa2c375 100644
--- a/parse.y
+++ b/parse.y
@@ -1494,7 +1494,6 @@ static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYP
 #define set_value(val) (p->s_lvalue = val)
 static VALUE defs(struct parser_params *p, VALUE head, VALUE args, VALUE bodystmt);
 static VALUE backref_error(struct parser_params*, NODE *, VALUE);
-static VALUE ripper_assignable(struct parser_params *p, ID id, VALUE lhs);
 static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
 static int id_is_var(struct parser_params *p, ID id);
 #endif
@@ -2965,7 +2964,7 @@ rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
                                         p->cur_arg = 0;
                                         p->ctxt.in_argdef = 1;
                                         $$ = NEW_OPT_ARG(assignable(p, $1, $3, &@$), &@$);
-                                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:3) %*/
+                                    /*% ripper: [$:$, $:3] %*/
                                     }
                                 ;
 
@@ -3693,13 +3692,13 @@ mlhs_post	: mlhs_item
 
 mlhs_node	: user_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | primary_value '[' opt_call_args rbracket
                     {
@@ -3745,13 +3744,13 @@ mlhs_node	: user_variable
 
 lhs		: user_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | primary_value '[' opt_call_args rbracket
                     {
@@ -4988,7 +4987,6 @@ f_marg		: f_norm_arg
                     {
                         $$ = assignable(p, $1, 0, &@$);
                         mark_lvar_used(p, $$);
-                    /*% ripper: ripper_assignable(p, $1, $:1) %*/
                     }
                 | tLPAREN f_margs rparen
                     {
@@ -5038,9 +5036,9 @@ f_margs		: f_marg_list
 
 f_rest_marg	: tSTAR f_norm_arg
                     {
+                    /*% ripper: $:2 %*/
                         $$ = assignable(p, $2, 0, &@$);
                         mark_lvar_used(p, $$);
-                    /*% ripper: ripper_assignable(p, $2, $:2) %*/
                     }
                 | tSTAR
                     {
@@ -5773,8 +5771,8 @@ p_find		: p_rest ',' p_args_post ',' p_rest
 p_rest		: tSTAR tIDENTIFIER
                     {
                         error_duplicate_pattern_variable(p, $2, &@2);
+                    /*% ripper: var_field!($:2) %*/
                         $$ = assignable(p, $2, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $2, var_field!($:2)) %*/
                     }
                 | tSTAR
                     {
@@ -5843,7 +5841,7 @@ p_kw		: p_kw_label p_expr
                         }
                         error_duplicate_pattern_variable(p, $1, &@1);
                         $$ = list_append(p, NEW_LIST(NEW_SYM(rb_id2str($1), &@$), &@$), assignable(p, $1, 0, &@$));
-                    /*% ripper: [ripper_assignable(p, $1, $:1), Qnil] %*/
+                    /*% ripper: [$:1, Qnil] %*/
                     }
                 ;
 
@@ -5952,8 +5950,8 @@ p_primitive	: literal
 p_variable	: tIDENTIFIER
                     {
                         error_duplicate_pattern_variable(p, $1, &@1);
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
@@ -6389,13 +6387,13 @@ var_ref		: user_variable
 
 var_lhs		: user_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 | keyword_variable
                     {
+                    /*% ripper: var_field!($:1) %*/
                         $$ = assignable(p, $1, 0, &@$);
-                    /*% ripper: ripper_assignable(p, $1, var_field!($:1)) %*/
                     }
                 ;
 
@@ -6687,14 +6685,14 @@ f_kw		: f_label arg_value
                         p->cur_arg = 0;
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, $2, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:2) %*/
+                    /*% ripper: [$:$, $:2] %*/
                     }
                 | f_label
                     {
                         p->cur_arg = 0;
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, NODE_SPECIAL_REQUIRED_KEYWORD, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), 0) %*/
+                    /*% ripper: [$:$, 0] %*/
                     }
                 ;
 
@@ -6702,13 +6700,13 @@ f_block_kw	: f_label primary_value
                     {
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, $2, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), $:2) %*/
+                    /*% ripper: [$:$, $:2] %*/
                     }
                 | f_label
                     {
                         p->ctxt.in_argdef = 1;
                         $$ = new_kw_arg(p, assignable(p, $1, NODE_SPECIAL_REQUIRED_KEYWORD, &@$), &@$);
-                    /*% ripper: rb_assoc_new(ripper_assignable(p, $1, $:1), 0) %*/
+                    /*% ripper: [$:$, 0] %*/
                     }
                 ;
 
@@ -13664,19 +13662,11 @@ assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc)
 /* TODO: FIXME */
 #ifndef RIPPER
     if (err) yyerror1(loc, err);
+#else
+    if (err) set_value(assign_error(p, err, p->s_lvalue));
 #endif
     return NEW_ERROR(loc);
 }
-#ifdef RIPPER
-static VALUE
-ripper_assignable(struct parser_params *p, ID id, VALUE lhs)
-{
-    const char *err = 0;
-    assignable0(p, id, &err);
-    if (err) lhs = assign_error(p, err, lhs);
-    return lhs;
-}
-#endif
 
 static int
 is_private_local_id(struct parser_params *p, ID name)

From 5bba5fb739364180da7f2208e9c0cfd0ac7b26f8 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 19:52:18 +0900
Subject: [PATCH 128/242] ripper: Describe `var_ref` for `user_variable` in
 ripper DSL

---
 parse.y | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/parse.y b/parse.y
index 9057f90fa2c375..7eeb8c05225165 100644
--- a/parse.y
+++ b/parse.y
@@ -1743,8 +1743,10 @@ endless_method_name(struct parser_params *p, ID mid, const YYLTYPE *loc)
 
 #ifndef RIPPER
 # define ifndef_ripper(x) (x)
+# define ifdef_ripper(r,x) (x)
 #else
 # define ifndef_ripper(x)
+# define ifdef_ripper(r,x) (r)
 #endif
 
 # define rb_warn0(fmt)         WARN_CALL(WARN_ARGS(fmt, 1))
@@ -6366,17 +6368,12 @@ keyword_variable: keyword_nil {$$ = KWD2EID(nil, $1);}
 var_ref		: user_variable
                     {
                         if (!($$ = gettable(p, $1, &@$))) $$ = NEW_ERROR(&@$);
-                    /*%%%*/
-                    /*%
-                        if (id_is_var(p, $1)) {
-                            VALUE val = dispatch1(var_ref, get_value($:1));
-                            set_value(val);
+                        if (ifdef_ripper(id_is_var(p, $1), false)) {
+                        /*% ripper: var_ref!($:1) %*/
                         }
                         else {
-                            VALUE val = dispatch1(vcall, get_value($:1));
-                            set_value(val);
+                        /*% ripper: vcall!($:1) %*/
                         }
-                    %*/
                     }
                 | keyword_variable
                     {

From 4c7ec5e0148bda451631d738af95d528a507557f Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 19:55:44 +0900
Subject: [PATCH 129/242] ripper: Extend to represent array access and splat

---
 ext/ripper/tools/dsl.rb | 106 +++++++++++++++++++++++++++++++---------
 1 file changed, 82 insertions(+), 24 deletions(-)

diff --git a/ext/ripper/tools/dsl.rb b/ext/ripper/tools/dsl.rb
index b55952cbeec9ec..38f859dd97ed61 100644
--- a/ext/ripper/tools/dsl.rb
+++ b/ext/ripper/tools/dsl.rb
@@ -43,54 +43,115 @@ def to_s
     end
   }
 
+  class Var
+    class Table < Hash
+      def initialize(&block)
+        super() {|tbl, arg|
+          tbl.fetch(arg, &block)
+        }
+      end
+
+      def fetch(arg, &block)
+        super {
+          self[arg] = Var.new(self, arg, &block)
+        }
+      end
+
+      def add(&block)
+        v = new_var
+        self[v] = Var.new(self, v, &block)
+      end
+
+      def defined?(name)
+        name = name.to_s
+        any? {|_, v| v.var == name}
+      end
+
+      def new_var
+        "v#{size+1}"
+      end
+    end
+
+    attr_reader :var, :value
+
+    PRETTY_PRINT_INSTANCE_VARIABLES = instance_methods(false).freeze
+
+    def pretty_print_instance_variables
+      PRETTY_PRINT_INSTANCE_VARIABLES
+    end
+
+    alias to_s var
+
+    def initialize(table, arg, &block)
+      @var = table.new_var
+      @value = yield arg
+      @table = table
+    end
+
+    # Indexing.
+    #
+    #   $:1 -> v1=get_value($:1)
+    #   $:1[0] -> rb_ary_entry(v1, 0)
+    #   $:1[0..1] -> [rb_ary_entry(v1, 0), rb_ary_entry(v1, 1)]
+    #   *$:1[0..1] -> rb_ary_entry(v1, 0), rb_ary_entry(v1, 1)
+    #
+    # Splat needs `[range]` because `Var` does not have the length info.
+    def [](idx)
+      if ::Range === idx
+        idx.map {|i| self[i]}
+      else
+        @table.fetch("#@var[#{idx}]") {"rb_ary_entry(#{@var}, #{idx})"}
+      end
+    end
+  end
+
   def initialize(code, options, lineno = nil, indent: "\t\t\t")
     @lineno = lineno
     @indent = indent
     @events = {}
     @error = options.include?("error")
-    @brace = options.include?("brace")
     if options.include?("final")
       @final = "p->result"
     else
       @final = (options.grep(/\A\$#{NAME_PATTERN}\z/o)[0] || "p->s_lvalue")
     end
-    @vars = 0
 
-    # struct parser_params *p
-    p = p = "p"
-
-    @code = +""
+    bind = dsl_binding
+    @var_table = Var::Table.new {|arg| "get_value(#{arg})"}
     code = code.gsub(%r[\G#{NOT_REF_PATTERN}\K(\$|\$:|@)#{TAG_PATTERN}?#{NAME_PATTERN}]o) {
       if (arg = $&) == "$:$"
         '"p->s_lvalue"'
       elsif arg.start_with?("$:")
-        %["get_value(#{arg})"]
+        "(#{@var_table[arg]}=@var_table[#{arg.dump}])"
       else
         arg.dump
       end
     }
-    @last_value = eval(code)
+    @last_value = bind.eval(code)
   rescue SyntaxError
     $stderr.puts "error on line #{@lineno}" if @lineno
     raise
   end
 
+  def dsl_binding(p = "p")
+    # struct parser_params *p
+    binding
+  end
+
   attr_reader :events
 
   undef lambda
   undef hash
-  undef class
+  undef :class
 
   def generate
-    s = "#@code#@final=#@last_value;"
-    s = "{VALUE #{ (1..@vars).map {|v| "v#{ v }" }.join(",") };#{ s }}" if @vars > 0
+    s = "#@final=#@last_value;"
     s << "ripper_error(p);" if @error
-    s = "{#{ s }}" if @brace
-    "#{@indent}#{s}"
-  end
-
-  def new_var
-    "v#{ @vars += 1 }"
+    unless @var_table.empty?
+      vars = @var_table.map {|_, v| "#{v.var}=#{v.value}"}.join(", ")
+      s = "VALUE #{ vars }; #{ s }"
+    end
+    "#{@indent}{#{s}}"
   end
 
   def add_event(event, args)
@@ -98,19 +159,16 @@ def add_event(event, args)
     @events[event] = args.size
     vars = []
     args.each do |arg|
-      vars << v = new_var
-      @code << "#{ v }=#{ arg };"
+      arg = @var_table.add {arg} unless Var === arg
+      vars << arg
     end
-    v = new_var
-    d = "dispatch#{ args.size }(#{ [event, *vars].join(",") })"
-    @code << "#{ v }=#{ d };"
-    v
+    @var_table.add {"dispatch#{ args.size }(#{ [event, *vars].join(",") })"}
   end
 
   def method_missing(event, *args)
     if event.to_s =~ /!\z/
       add_event(event, args)
-    elsif args.empty? and /\Aid[A-Z_]/ =~ event.to_s
+    elsif args.empty? and (/\Aid[A-Z_]/ =~ event or @var_table.defined?(event))
       event
     else
       "#{ event }(#{ args.map(&:to_s).join(", ") })"

From be0f2ab32dd0c5f7960ff0b6941a6d1cc66037e2 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 20:01:05 +0900
Subject: [PATCH 130/242] ripper: Splat `$:head` for `defs!`

---
 parse.y | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)

diff --git a/parse.y b/parse.y
index 7eeb8c05225165..4e002763a56e45 100644
--- a/parse.y
+++ b/parse.y
@@ -1492,7 +1492,6 @@ static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYP
 #ifdef RIPPER
 #define get_value(idx) (rb_ary_entry(p->s_value_stack, idx))
 #define set_value(val) (p->s_lvalue = val)
-static VALUE defs(struct parser_params *p, VALUE head, VALUE args, VALUE bodystmt);
 static VALUE backref_error(struct parser_params*, NODE *, VALUE);
 static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
 static int id_is_var(struct parser_params *p, ID id);
@@ -3343,7 +3342,7 @@ command_asgn	: lhs '=' lex_ctxt command_rhs
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
                     /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
-                    /*% ripper: defs(p, $:head, $:args, $:$) %*/
+                    /*% ripper: defs!(*$:head[0..2], $:args, $:$) %*/
                         local_pop(p);
                     }
                 | backref tOP_ASGN lex_ctxt command_rhs
@@ -4141,7 +4140,7 @@ arg		: lhs '=' lex_ctxt arg_rhs
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
                     /*% ripper: bodystmt!($:bodystmt, Qnil, Qnil, Qnil) %*/
-                    /*% ripper: defs(p, $:head, $:args, $:$) %*/
+                    /*% ripper: defs!(*$:head[0..2], $:args, $:$) %*/
                         local_pop(p);
                     }
                 | primary
@@ -4742,7 +4741,7 @@ primary		: literal
                         $bodystmt = new_scope_body(p, $args, $bodystmt, &@$);
                         ($$ = $head->nd_def)->nd_loc = @$;
                         RNODE_DEFS($$)->nd_defn = $bodystmt;
-                    /*% ripper: defs(p, $:head, $:args, $:bodystmt) %*/
+                    /*% ripper: defs!(*$:head[0..2], $:args, $:bodystmt) %*/
                         local_pop(p);
                     }
                 | keyword_break
@@ -13789,17 +13788,6 @@ rb_backref_error(struct parser_params *p, NODE *node)
 }
 
 #ifdef RIPPER
-static VALUE
-defs(struct parser_params *p, VALUE head, VALUE args, VALUE bodystmt)
-{
-    return dispatch5(defs,
-                     rb_ary_entry(head, 0), /* nd_recv */
-                     rb_ary_entry(head, 1), /* dot_or_colon */
-                     rb_ary_entry(head, 2), /* nd_mid */
-                     args,
-                     bodystmt);
-}
-
 static VALUE
 backref_error(struct parser_params *p, NODE *node, VALUE expr)
 {

From 3e81bc3d5306dc4bbe107367dba665d48bcc988d Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 20:05:17 +0900
Subject: [PATCH 131/242] ripper: Splat `$:opt_args_tail` for `params!`

---
 parse.y | 65 +++++++++++++++++++++++++--------------------------------
 1 file changed, 28 insertions(+), 37 deletions(-)

diff --git a/parse.y b/parse.y
index 4e002763a56e45..e5bac078b159be 100644
--- a/parse.y
+++ b/parse.y
@@ -1610,15 +1610,6 @@ void ripper_error(struct parser_params *p);
 
 static VALUE ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs);
 
-static VALUE
-ripper_new_args(struct parser_params *p, VALUE pre_args, VALUE opt_args, VALUE rest_arg, VALUE post_args, VALUE tail)
-{
-    VALUE kw_args = rb_ary_entry(tail, 0);
-    VALUE kw_rest_arg = rb_ary_entry(tail, 1);
-    VALUE block = rb_ary_entry(tail, 2);
-    return dispatch7(params, pre_args, opt_args, rest_arg, post_args, kw_args, kw_rest_arg, block);
-}
-
 static VALUE
 ripper_new_array_pattern(struct parser_params *p, VALUE constant, VALUE pre_arg, VALUE aryptn)
 {
@@ -5091,27 +5082,27 @@ excessed_comma	: ','
 block_param	: f_arg ',' f_optarg(primary_value) ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, 0, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, Qnil, $:6) %*/
+                    /*% ripper: params!($:1, $:3, $:5, Qnil, *$:6[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, $7, $8, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, $:7, $:8) %*/
+                    /*% ripper: params!($:1, $:3, $:5, $:7, *$:8[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, Qnil, $:4) %*/
+                    /*% ripper: params!($:1, $:3, Qnil, Qnil, *$:4[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(primary_value) ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, $:5, $:6) %*/
+                    /*% ripper: params!($:1, $:3, Qnil, $:5, *$:6[0..2]) %*/
                     }
                 | f_arg ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, Qnil, $:4) %*/
+                    /*% ripper: params!($:1, Qnil, $:3, Qnil, *$:4[0..2]) %*/
                     }
                 | f_arg excessed_comma
                     {
@@ -5122,47 +5113,47 @@ block_param	: f_arg ',' f_optarg(primary_value) ',' f_rest_arg opt_args_tail(blo
                 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, $:5, $:6) %*/
+                    /*% ripper: params!($:1, Qnil, $:3, $:5, *$:6[0..2]) %*/
                     }
                 | f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, $1, 0, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, Qnil, Qnil, $:2) %*/
+                    /*% ripper: params!($:1, Qnil, Qnil, Qnil, *$:2[0..2]) %*/
                     }
                 | f_optarg(primary_value) ',' f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, Qnil, $:4) %*/
+                    /*% ripper: params!(Qnil, $:1, $:3, Qnil, *$:4[0..2]) %*/
                     }
                 | f_optarg(primary_value) ',' f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, $:5, $:6) %*/
+                    /*% ripper: params!(Qnil, $:1, $:3, $:5, *$:6[0..2]) %*/
                     }
                 | f_optarg(primary_value) opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, Qnil, $:2) %*/
+                    /*% ripper: params!(Qnil, $:1, Qnil, Qnil, *$:2[0..2]) %*/
                     }
                 | f_optarg(primary_value) ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, $:3, $:4) %*/
+                    /*% ripper: params!(Qnil, $:1, Qnil, $:3, *$:4[0..2]) %*/
                     }
                 | f_rest_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, Qnil, $:2) %*/
+                    /*% ripper: params!(Qnil, Qnil, $:1, Qnil, *$:2[0..2]) %*/
                     }
                 | f_rest_arg ',' f_arg opt_args_tail(block_args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, $:3, $:4) %*/
+                    /*% ripper: params!(Qnil, Qnil, $:1, $:3, *$:4[0..2]) %*/
                     }
                 | block_args_tail
                     {
                         $$ = new_args(p, 0, 0, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, $:1) %*/
+                    /*% ripper: params!(Qnil, Qnil, Qnil, Qnil, *$:1[0..2]) %*/
                     }
                 ;
 
@@ -6484,72 +6475,72 @@ args_tail	: f_kwarg(f_kw) ',' f_kwrest opt_f_block_arg
 f_args		: f_arg ',' f_optarg(arg_value) ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, 0, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, Qnil, $:6) %*/
+                    /*% ripper: params!($:1, $:3, $:5, Qnil, *$:6[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, $5, $7, $8, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, $:5, $:7, $:8) %*/
+                    /*% ripper: params!($:1, $:3, $:5, $:7, *$:8[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, Qnil, $:4) %*/
+                    /*% ripper: params!($:1, $:3, Qnil, Qnil, *$:4[0..2]) %*/
                     }
                 | f_arg ',' f_optarg(arg_value) ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, $3, 0, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, $:3, Qnil, $:5, $:6) %*/
+                    /*% ripper: params!($:1, $:3, Qnil, $:5, *$:6[0..2]) %*/
                     }
                 | f_arg ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, Qnil, $:4) %*/
+                    /*% ripper: params!($:1, Qnil, $:3, Qnil, *$:4[0..2]) %*/
                     }
                 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, $:3, $:5, $:6) %*/
+                    /*% ripper: params!($:1, Qnil, $:3, $:5, *$:6[0..2]) %*/
                     }
                 | f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, $1, 0, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, $:1, Qnil, Qnil, Qnil, $:2) %*/
+                    /*% ripper: params!($:1, Qnil, Qnil, Qnil, *$:2[0..2]) %*/
                     }
                 | f_optarg(arg_value) ',' f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, 0, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, Qnil, $:4) %*/
+                    /*% ripper: params!(Qnil, $:1, $:3, Qnil, *$:4[0..2]) %*/
                     }
                 | f_optarg(arg_value) ',' f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, $3, $5, $6, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, $:3, $:5, $:6) %*/
+                    /*% ripper: params!(Qnil, $:1, $:3, $:5, *$:6[0..2]) %*/
                     }
                 | f_optarg(arg_value) opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, Qnil, $:2) %*/
+                    /*% ripper: params!(Qnil, $:1, Qnil, Qnil, *$:2[0..2]) %*/
                     }
                 | f_optarg(arg_value) ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, $1, 0, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, $:1, Qnil, $:3, $:4) %*/
+                    /*% ripper: params!(Qnil, $:1, Qnil, $:3, *$:4[0..2]) %*/
                     }
                 | f_rest_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, 0, $2, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, Qnil, $:2) %*/
+                    /*% ripper: params!(Qnil, Qnil, $:1, Qnil, *$:2[0..2]) %*/
                     }
                 | f_rest_arg ',' f_arg opt_args_tail(args_tail)
                     {
                         $$ = new_args(p, 0, 0, $1, $3, $4, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, $:1, $:3, $:4) %*/
+                    /*% ripper: params!(Qnil, Qnil, $:1, $:3, *$:4[0..2]) %*/
                     }
                 | args_tail
                     {
                         $$ = new_args(p, 0, 0, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_args(p, Qnil, Qnil, Qnil, Qnil, $:1) %*/
+                    /*% ripper: params!(Qnil, Qnil, Qnil, Qnil, *$:1[0..2]) %*/
                     }
                 | /* none */
                     {

From 978c31f04a74a83f1c0d4c3faab5795aa999bb7e Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 20:14:22 +0900
Subject: [PATCH 132/242] ripper: Splat array patterns with `pre_arg`

---
 parse.y | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/parse.y b/parse.y
index e5bac078b159be..85e377e2d0ca91 100644
--- a/parse.y
+++ b/parse.y
@@ -1611,12 +1611,8 @@ void ripper_error(struct parser_params *p);
 static VALUE ripper_formal_argument(struct parser_params *p, ID id, VALUE lhs);
 
 static VALUE
-ripper_new_array_pattern(struct parser_params *p, VALUE constant, VALUE pre_arg, VALUE aryptn)
+aryptn_pre_args(struct parser_params *p, VALUE pre_arg, VALUE pre_args)
 {
-    VALUE pre_args  = rb_ary_entry(aryptn, 0);
-    VALUE rest_arg  = rb_ary_entry(aryptn, 1);
-    VALUE post_args = rb_ary_entry(aryptn, 2);
-
     if (!NIL_P(pre_arg)) {
         if (!NIL_P(pre_args)) {
             rb_ary_unshift(pre_args, pre_arg);
@@ -1625,7 +1621,7 @@ ripper_new_array_pattern(struct parser_params *p, VALUE constant, VALUE pre_arg,
             pre_args = rb_ary_new_from_args(1, pre_arg);
         }
     }
-    return dispatch4(aryptn, constant, pre_args, rest_arg, post_args);
+    return pre_args;
 }
 
 static VALUE
@@ -5543,13 +5539,13 @@ p_top_expr_body : p_expr
                     {
                         $$ = new_array_pattern_tail(p, 0, 1, 0, 0, &@$);
                         $$ = new_array_pattern(p, 0, $1, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, $:1, rb_ary_new()) %*/
+                    /*% ripper: aryptn!(Qnil, [$:1], Qnil, Qnil) %*/
                     }
                 | p_expr ',' p_args
                     {
                         $$ = new_array_pattern(p, 0, $1, $3, &@$);
                         nd_set_first_loc($$, @1.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, $:1, $:3) %*/
+                    /*% ripper: aryptn!(Qnil, aryptn_pre_args(p, $:1, $:3[0]), *$:3[1..2]) %*/
                     }
                 | p_find
                     {
@@ -5559,7 +5555,7 @@ p_top_expr_body : p_expr
                 | p_args_tail
                     {
                         $$ = new_array_pattern(p, 0, 0, $1, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, $:1) %*/
+                    /*% ripper: aryptn!(Qnil, *$:1[0..2]) %*/
                     }
                 | p_kwargs
                     {
@@ -5610,7 +5606,7 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_array_pattern(p, $p_const, 0, $p_args, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, $:p_args) %*/
+                    /*% ripper: aryptn!($:p_const, *$:p_args[0..2]) %*/
                     }
                 | p_const p_lparen[p_pktbl] p_find rparen
                     {
@@ -5630,14 +5626,14 @@ p_expr_basic	: p_value
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, $p_const, 0, $$, &@$);
-                        /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, rb_ary_new()) %*/
+                        /*% ripper: aryptn!($:p_const, Qnil, Qnil, Qnil) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_args rbracket
                     {
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_array_pattern(p, $p_const, 0, $p_args, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_array_pattern(p, $:p_const, Qnil, $:p_args) %*/
+                    /*% ripper: aryptn!($:p_const, *$:p_args[0..2]) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_find rbracket
                     {
@@ -5657,12 +5653,12 @@ p_expr_basic	: p_value
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, $1, 0, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, $:1, Qnil, rb_ary_new()) %*/
+                    /*% ripper: aryptn!($:1, Qnil, Qnil, Qnil) %*/
                     }
                 | tLBRACK p_args rbracket
                     {
                         $$ = new_array_pattern(p, 0, 0, $p_args, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, $:p_args) %*/
+                    /*% ripper: aryptn!(Qnil, *$:p_args[0..2]) %*/
                     }
                 | tLBRACK p_find rbracket
                     {
@@ -5673,7 +5669,7 @@ p_expr_basic	: p_value
                     {
                         $$ = new_array_pattern_tail(p, 0, 0, 0, 0, &@$);
                         $$ = new_array_pattern(p, 0, 0, $$, &@$);
-                    /*% ripper: ripper_new_array_pattern(p, Qnil, Qnil, rb_ary_new()) %*/
+                    /*% ripper: aryptn!(Qnil, Qnil, Qnil, Qnil) %*/
                     }
                 | tLBRACE p_pktbl lex_ctxt[ctxt]
                     {

From 501dbf2bcaab5003663b6eabb2d7660209bc786e Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 20:20:23 +0900
Subject: [PATCH 133/242] ripper: Splat hash patterns

---
 parse.y | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/parse.y b/parse.y
index 85e377e2d0ca91..00411a49c9e28c 100644
--- a/parse.y
+++ b/parse.y
@@ -1624,15 +1624,6 @@ aryptn_pre_args(struct parser_params *p, VALUE pre_arg, VALUE pre_args)
     return pre_args;
 }
 
-static VALUE
-ripper_new_hash_pattern(struct parser_params *p, VALUE constant, VALUE hshptn)
-{
-    VALUE kw_args     = rb_ary_entry(hshptn, 0);
-    VALUE kw_rest_arg = rb_ary_entry(hshptn, 1);
-
-    return dispatch3(hshptn, constant, kw_args, kw_rest_arg);
-}
-
 static VALUE
 ripper_new_find_pattern(struct parser_params *p, VALUE constant, VALUE fndptn)
 {
@@ -5560,7 +5551,7 @@ p_top_expr_body : p_expr
                 | p_kwargs
                     {
                         $$ = new_hash_pattern(p, 0, $1, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, $:1) %*/
+                    /*% ripper: hshptn!(Qnil, *$:1[0..1]) %*/
                     }
                 ;
 
@@ -5620,7 +5611,7 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_hash_pattern(p, $p_const, $p_kwargs, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_hash_pattern(p, $:p_const, $:p_kwargs) %*/
+                    /*% ripper: hshptn!($:p_const, *$:p_kwargs[0..1]) %*/
                     }
                 | p_const '(' rparen
                     {
@@ -5647,7 +5638,7 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_hash_pattern(p, $p_const, $p_kwargs, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_hash_pattern(p, $:p_const, $:p_kwargs) %*/
+                    /*% ripper: hshptn!($:p_const, *$:p_kwargs[0..1]) %*/
                     }
                 | p_const '[' rbracket
                     {
@@ -5680,13 +5671,13 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         p->ctxt.in_kwarg = $ctxt.in_kwarg;
                         $$ = new_hash_pattern(p, 0, $p_kwargs, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, $:p_kwargs) %*/
+                    /*% ripper: hshptn!(Qnil, *$:p_kwargs[0..1]) %*/
                     }
                 | tLBRACE rbrace
                     {
                         $$ = new_hash_pattern_tail(p, 0, 0, &@$);
                         $$ = new_hash_pattern(p, 0, $$, &@$);
-                    /*% ripper: ripper_new_hash_pattern(p, Qnil, [Qnil, Qnil]) %*/
+                    /*% ripper: hshptn!(Qnil, Qnil, Qnil) %*/
                     }
                 | tLPAREN p_pktbl p_expr rparen
                     {

From c773453c77c44f79d49d0ba48557a26950b3a4b9 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 12 May 2024 20:23:38 +0900
Subject: [PATCH 134/242] ripper: Splat find patterns

---
 parse.y | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/parse.y b/parse.y
index 00411a49c9e28c..9a2535bd2db4dc 100644
--- a/parse.y
+++ b/parse.y
@@ -1624,16 +1624,6 @@ aryptn_pre_args(struct parser_params *p, VALUE pre_arg, VALUE pre_args)
     return pre_args;
 }
 
-static VALUE
-ripper_new_find_pattern(struct parser_params *p, VALUE constant, VALUE fndptn)
-{
-    VALUE pre_rest_arg  = rb_ary_entry(fndptn, 0);
-    VALUE args          = rb_ary_entry(fndptn, 1);
-    VALUE post_rest_arg = rb_ary_entry(fndptn, 2);
-
-    return dispatch4(fndptn, constant, pre_rest_arg, args, post_rest_arg);
-}
-
 #define ID2VAL(id) STATIC_ID2SYM(id)
 #define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
 #endif /* RIPPER */
@@ -5541,7 +5531,7 @@ p_top_expr_body : p_expr
                 | p_find
                     {
                         $$ = new_find_pattern(p, 0, $1, &@$);
-                    /*% ripper: ripper_new_find_pattern(p, Qnil, $:1) %*/
+                    /*% ripper: fndptn!(Qnil, *$:1[0..2]) %*/
                     }
                 | p_args_tail
                     {
@@ -5604,7 +5594,7 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_find_pattern(p, $p_const, $p_find, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_find_pattern(p, $:p_const, $:p_find) %*/
+                    /*% ripper: fndptn!($:p_const, *$:p_find[0..2]) %*/
                     }
                 | p_const p_lparen[p_pktbl] p_kwargs rparen
                     {
@@ -5631,7 +5621,7 @@ p_expr_basic	: p_value
                         pop_pktbl(p, $p_pktbl);
                         $$ = new_find_pattern(p, $p_const, $p_find, &@$);
                         nd_set_first_loc($$, @p_const.beg_pos);
-                    /*% ripper: ripper_new_find_pattern(p, $:p_const, $:p_find) %*/
+                    /*% ripper: fndptn!($:p_const, *$:p_find[0..2]) %*/
                     }
                 | p_const p_lbracket[p_pktbl] p_kwargs rbracket
                     {
@@ -5654,7 +5644,7 @@ p_expr_basic	: p_value
                 | tLBRACK p_find rbracket
                     {
                         $$ = new_find_pattern(p, 0, $p_find, &@$);
-                    /*% ripper: ripper_new_find_pattern(p, Qnil, $:p_find) %*/
+                    /*% ripper: fndptn!(Qnil, *$:p_find[0..2]) %*/
                     }
                 | tLBRACK rbracket
                     {

From 8277cf0799145bed0c813bfcc187739f77b3102d Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Tue, 21 May 2024 17:03:34 +0900
Subject: [PATCH 135/242] [Bug #20499] Use consistent version tools with CC

As Apple Xcode is relocatable and selectable with `xcode-select`, use
consistent versions of commands in the same location.
---
 configure.ac | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/configure.ac b/configure.ac
index d787bc3502eb71..169662ca93cf0b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -248,10 +248,16 @@ AS_CASE(["${build_os}"],
     AC_PATH_TOOL([NM], [nm], [/usr/ccs/bin/nm], [/usr/ccs/bin:$PATH])
 ],
 [darwin*], [
-    # For Apple clang version 14.0.3 (clang-1403.0.22.14.1)
-    ac_cv_prog_ac_ct_AR=`$CC -print-prog-name=ar`
-    ac_cv_prog_ac_ct_LD=`$CC -print-prog-name=ld`
-    ac_cv_prog_ac_ct_NM=`$CC -print-prog-name=nm`
+    # As Apple Xcode is relocatable and selectable with `xcode-select`,
+    # use consistent versions of commands in the same location.
+    AC_MSG_CHECKING([Xcode tools])
+    AS_CASE([$ac_cv_prog_ac_ct_CC],
+        [/*], [],
+        [ac_cv_prog_ac_ct_CC=`command -v $ac_cv_prog_ac_ct_CC`])
+    AC_MSG_RESULT(CC=$ac_cv_prog_ac_ct_CC)
+    ac_cv_prog_ac_ct_AR=${ac_cv_prog_ac_ct_CC%/*}/ar
+    ac_cv_prog_ac_ct_LD=${ac_cv_prog_ac_ct_CC%/*}/ld
+    ac_cv_prog_ac_ct_NM=${ac_cv_prog_ac_ct_CC%/*}/nm
 ])
 AS_CASE(["${target_os}"],
 [cygwin*|msys*|mingw*|darwin*], [

From ff43b4a28b137af6435603eccb57d6cae85d210b Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 09:55:31 -0400
Subject: [PATCH 136/242] [ruby/prism] Add error for numbered parameter used in
 inner block

https://github.com/ruby/prism/commit/c386ba6d48
---
 prism/config.yml                     |  4 ++-
 prism/parser.h                       |  1 +
 prism/prism.c                        | 37 ++++++++++++++++++++++------
 prism/templates/src/diagnostic.c.erb |  4 ++-
 test/prism/errors_test.rb            |  2 +-
 5 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/prism/config.yml b/prism/config.yml
index 6b4b1aa9c0e1dc..cfcfd2e7aad176 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -114,6 +114,7 @@ errors:
   - EXPRESSION_NOT_WRITABLE_FILE
   - EXPRESSION_NOT_WRITABLE_LINE
   - EXPRESSION_NOT_WRITABLE_NIL
+  - EXPRESSION_NOT_WRITABLE_NUMBERED
   - EXPRESSION_NOT_WRITABLE_SELF
   - EXPRESSION_NOT_WRITABLE_TRUE
   - FLOAT_PARSE
@@ -185,9 +186,10 @@ errors:
   - NO_LOCAL_VARIABLE
   - NOT_EXPRESSION
   - NUMBER_LITERAL_UNDERSCORE
+  - NUMBERED_PARAMETER_INNER_BLOCK
   - NUMBERED_PARAMETER_IT
   - NUMBERED_PARAMETER_ORDINARY
-  - NUMBERED_PARAMETER_OUTER_SCOPE
+  - NUMBERED_PARAMETER_OUTER_BLOCK
   - OPERATOR_MULTI_ASSIGN
   - OPERATOR_WRITE_ARGUMENTS
   - OPERATOR_WRITE_BLOCK
diff --git a/prism/parser.h b/prism/parser.h
index 8054e332f73b30..ff1261841cc016 100644
--- a/prism/parser.h
+++ b/prism/parser.h
@@ -609,6 +609,7 @@ static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS = 0x10;
 static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_BLOCK = 0x20;
 static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_ALL = 0x40;
 
+static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_INNER = -2;
 static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED = -1;
 static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_NONE = 0;
 
diff --git a/prism/prism.c b/prism/prism.c
index cf8ce7c8301a40..e14679939397a2 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -13365,14 +13365,20 @@ parse_write(pm_parser_t *parser, pm_node_t *target, pm_token_t *operator, pm_nod
             return (pm_node_t *) node;
         }
         case PM_LOCAL_VARIABLE_READ_NODE: {
-            pm_refute_numbered_parameter(parser, target->location.start, target->location.end);
             pm_local_variable_read_node_t *local_read = (pm_local_variable_read_node_t *) target;
 
             pm_constant_id_t name = local_read->name;
+            pm_location_t name_loc = target->location;
+
             uint32_t depth = local_read->depth;
-            pm_locals_unread(&pm_parser_scope_find(parser, depth)->locals, name);
+            pm_scope_t *scope = pm_parser_scope_find(parser, depth);
 
-            pm_location_t name_loc = target->location;
+            if (pm_token_is_numbered_parameter(target->location.start, target->location.end)) {
+                pm_diagnostic_id_t diag_id = scope->parameters > PM_SCOPE_NUMBERED_PARAMETERS_NONE ? PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED : PM_ERR_PARAMETER_NUMBERED_RESERVED;
+                PM_PARSER_ERR_FORMAT(parser, target->location.start, target->location.end, diag_id, target->location.start);
+            }
+
+            pm_locals_unread(&scope->locals, name);
             pm_node_destroy(parser, target);
 
             return (pm_node_t *) pm_local_variable_write_node_create(parser, name, depth, value, &name_loc, operator);
@@ -15829,17 +15835,34 @@ parse_variable(pm_parser_t *parser) {
         } else if (current_scope->parameters & PM_SCOPE_PARAMETERS_IT) {
             pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_IT);
         } else if (outer_scope_using_numbered_parameters_p(parser)) {
-            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_OUTER_SCOPE);
+            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK);
+        } else if (current_scope->numbered_parameters == PM_SCOPE_NUMBERED_PARAMETERS_INNER) {
+            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK);
         } else {
             // Indicate that this scope is using numbered params so that child
             // scopes cannot. We subtract the value for the character '0' to get
             // the actual integer value of the number (only _1 through _9 are
             // valid).
             int8_t numbered_parameters = (int8_t) (parser->previous.start[1] - '0');
-            current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED;
 
-            if (numbered_parameters > current_scope->numbered_parameters) {
-                current_scope->numbered_parameters = numbered_parameters;
+            // If we're about to match an =, then this is an invalid use of
+            // numbered parameters. We'll create all of the necessary
+            // infrastructure around it, but not actually mark the scope as
+            // using numbered parameters so that we can get the right error
+            // message.
+            if (!match1(parser, PM_TOKEN_EQUAL)) {
+                current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED;
+
+                if (numbered_parameters > current_scope->numbered_parameters) {
+                    current_scope->numbered_parameters = numbered_parameters;
+                }
+
+                // Go through the parent scopes and mark them as being
+                // disallowed from using numbered parameters because this inner
+                // scope is using them.
+                for (pm_scope_t *scope = current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
+                    scope->numbered_parameters = PM_SCOPE_NUMBERED_PARAMETERS_INNER;
+                }
             }
 
             // When you use a numbered parameter, it implies the existence
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 57c52602f42689..30d6b0ffedc4be 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -197,6 +197,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EXPRESSION_NOT_WRITABLE_FILE]       = { "Can't assign to __FILE__", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_LINE]       = { "Can't assign to __LINE__", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_NIL]        = { "Can't assign to nil", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED]   = { "Can't assign to numbered parameter %.2s", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_SELF]       = { "Can't change the value of self", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE]       = { "Can't assign to true", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_FLOAT_PARSE]                        = { "could not parse the float '%.*s'", PM_ERROR_LEVEL_SYNTAX },
@@ -267,9 +268,10 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_NOT_EXPRESSION]                     = { "expected an expression after `not`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NO_LOCAL_VARIABLE]                  = { "%.*s: no such local variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBER_LITERAL_UNDERSCORE]          = { "number literal ending with a `_`", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK]     = { "numbered parameter is already used in inner block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when an 'it' parameter is defined", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_ORDINARY]        = { "numbered parameters are not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_NUMBERED_PARAMETER_OUTER_SCOPE]     = { "numbered parameter is already used in outer scope", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK]     = { "numbered parameter is already used in outer block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_MULTI_ASSIGN]              = { "unexpected operator for a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_WRITE_ARGUMENTS]           = { "unexpected operator after a call with arguments", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_WRITE_BLOCK]               = { "unexpected operator after a call with a block", PM_ERROR_LEVEL_SYNTAX },
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 3670b90dd76e16..6f926452fa8809 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -1377,7 +1377,7 @@ def test_defining_numbered_parameter
 
     def test_double_scope_numbered_parameters
       source = "-> { _1 + -> { _2 } }"
-      errors = [["numbered parameter is already used in outer scope", 15..17]]
+      errors = [["numbered parameter is already used in outer block", 15..17]]
 
       assert_errors expression(source), source, errors
     end

From bcbfc675a41579e72eb56e4fc50ddf203592868a Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 11:47:19 -0400
Subject: [PATCH 137/242] [PRISM] Enable TestSyntax#test_numbered_parameter

---
 test/.excludes-prism/TestSyntax.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index 0505330b1cc399..e611d13ce97e81 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,6 +1,5 @@
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
 exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
-exclude(:test_numbered_parameter, "should raise syntax error for numbered parameters in inner blocks")
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
 exclude(:test_warn_balanced, "missing warning for ** being interpreted as a binary operator")
 

From 16b0bb3d5370c48194e220bf4083887a316f4575 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 13:11:11 -0400
Subject: [PATCH 138/242] [PRISM] Enable TestSyntax#test_warn_balanced

---
 test/.excludes-prism/TestSyntax.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index e611d13ce97e81..4809924acc8a27 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,7 +1,6 @@
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
 exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
-exclude(:test_warn_balanced, "missing warning for ** being interpreted as a binary operator")
 
 exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")

From 42930d28a48bf7495180e81fd6e5cf742f3f47c7 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 13:08:08 -0400
Subject: [PATCH 139/242] [PRISM] Handle safe navigation in call target nodes

---
 prism_compile.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/prism_compile.c b/prism_compile.c
index 58c70748e1c37a..18f1d38b7dcec1 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -3962,6 +3962,13 @@ pm_compile_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *cons
 
         pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
 
+        LABEL *safe_label = NULL;
+        if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
+            safe_label = NEW_LABEL(location.line);
+            PUSH_INSN(parents, location, dup);
+            PUSH_INSNL(parents, location, branchnil, safe_label);
+        }
+
         if (state != NULL) {
             PUSH_INSN1(writes, location, topn, INT2FIX(1));
             pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
@@ -3972,7 +3979,9 @@ pm_compile_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *cons
         if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) flags |= VM_CALL_FCALL;
 
         PUSH_SEND_WITH_FLAG(writes, location, method_id, INT2FIX(1), INT2FIX(flags));
+        if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
         PUSH_INSN(writes, location, pop);
+        if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
 
         if (state != NULL) {
             PUSH_INSN(cleanup, location, pop);

From 89efb94fec9c78caab7ec4079bfe9e3f4e56a9a4 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 8 May 2024 15:32:24 -0400
Subject: [PATCH 140/242] [ruby/prism] Reconfigure rationals

This eliminates the subnode on RationalNode and replaces it with two
integer fields, which represent the ratio for the rational. It also
reduces those two integers if they both fit into 32 bits.

Importantly, this PR does not implement bignum reduction. That's something
I'd like to consider for the future, but it's simple enough for now to
leave them unreduced, which makes it more useful than it used to be.

https://github.com/ruby/prism/commit/86e06c7068
---
 lib/prism/node_ext.rb                         |   2 +-
 lib/prism/translation/parser/compiler.rb      |  24 +---
 prism/config.yml                              |  17 ++-
 prism/prism.c                                 |  72 ++++++++---
 prism/static_literals.c                       | 118 +++++++-----------
 prism/util/pm_integer.c                       |  38 +++++-
 prism/util/pm_integer.h                       |  15 +++
 test/prism/snapshots/numbers.txt              |  73 +++++------
 test/prism/snapshots/patterns.txt             |  42 +++----
 .../snapshots/seattlerb/ruby21_numbers.txt    |  14 +--
 test/prism/snapshots/symbols.txt              |   7 +-
 .../unparser/corpus/literal/literal.txt       |  26 ++--
 .../unparser/corpus/semantic/literal.txt      |  13 +-
 test/prism/snapshots/whitequark/complex.txt   |  13 +-
 test/prism/snapshots/whitequark/rational.txt  |  13 +-
 .../snapshots/whitequark/ruby_bug_11873_a.txt |  24 ++--
 16 files changed, 273 insertions(+), 238 deletions(-)

diff --git a/lib/prism/node_ext.rb b/lib/prism/node_ext.rb
index ceec76b8d6ad50..4761e5b9b27223 100644
--- a/lib/prism/node_ext.rb
+++ b/lib/prism/node_ext.rb
@@ -103,7 +103,7 @@ def value
   class RationalNode < Node
     # Returns the value of the node as a Ruby Rational.
     def value
-      Rational(numeric.is_a?(IntegerNode) ? numeric.value : slice.chomp("r"))
+      Rational(numerator, denominator)
     end
   end
 
diff --git a/lib/prism/translation/parser/compiler.rb b/lib/prism/translation/parser/compiler.rb
index a6c3118efd1a93..c3fa68231ce8b5 100644
--- a/lib/prism/translation/parser/compiler.rb
+++ b/lib/prism/translation/parser/compiler.rb
@@ -881,7 +881,7 @@ def visit_if_node(node)
         # 1i
         # ^^
         def visit_imaginary_node(node)
-          visit_numeric(node, builder.complex([imaginary_value(node), srange(node.location)]))
+          visit_numeric(node, builder.complex([Complex(0, node.numeric.value), srange(node.location)]))
         end
 
         # { foo: }
@@ -1514,7 +1514,7 @@ def visit_range_node(node)
         # 1r
         # ^^
         def visit_rational_node(node)
-          visit_numeric(node, builder.rational([rational_value(node), srange(node.location)]))
+          visit_numeric(node, builder.rational([node.value, srange(node.location)]))
         end
 
         # redo
@@ -1940,12 +1940,6 @@ def find_forwarding(node)
           forwarding
         end
 
-        # Because we have mutated the AST to allow for newlines in the middle of
-        # a rational, we need to manually handle the value here.
-        def imaginary_value(node)
-          Complex(0, node.numeric.is_a?(RationalNode) ? rational_value(node.numeric) : node.numeric.value)
-        end
-
         # Negate the value of a numeric node. This is a special case where you
         # have a negative sign on one line and then a number on the next line.
         # In normal Ruby, this will always be a method call. The parser gem,
@@ -1955,7 +1949,9 @@ def numeric_negate(message_loc, receiver)
           case receiver.type
           when :integer_node, :float_node
             receiver.copy(value: -receiver.value, location: message_loc.join(receiver.location))
-          when :rational_node, :imaginary_node
+          when :rational_node
+            receiver.copy(numerator: -receiver.numerator, location: message_loc.join(receiver.location))
+          when :imaginary_node
             receiver.copy(numeric: numeric_negate(message_loc, receiver.numeric), location: message_loc.join(receiver.location))
           end
         end
@@ -1974,16 +1970,6 @@ def procarg0?(parameters)
             parameters.block.nil?
         end
 
-        # Because we have mutated the AST to allow for newlines in the middle of
-        # a rational, we need to manually handle the value here.
-        def rational_value(node)
-          if node.numeric.is_a?(IntegerNode)
-            Rational(node.numeric.value)
-          else
-            Rational(node.slice.gsub(/\s/, "").chomp("r"))
-          end
-        end
-
         # Locations in the parser gem AST are generated using this class. We
         # store a reference to its constant to make it slightly faster to look
         # up.
diff --git a/prism/config.yml b/prism/config.yml
index cfcfd2e7aad176..08441ca4decfee 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -3231,8 +3231,21 @@ nodes:
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   - name: RationalNode
     fields:
-      - name: numeric
-        type: node
+      - name: flags
+        type: flags
+        kind: IntegerBaseFlags
+      - name: numerator
+        type: integer
+        comment: |
+          The numerator of the rational number.
+
+              1.5r # numerator 3
+      - name: denominator
+        type: integer
+        comment: |
+          The denominator of the rational number.
+
+              1.5r # denominator 2
     comment: |
       Represents a rational number literal.
 
diff --git a/prism/prism.c b/prism/prism.c
index e14679939397a2..a47aa08ce251ed 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -4290,7 +4290,7 @@ pm_float_node_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {
 }
 
 /**
- * Allocate and initialize a new FloatNode node from a FLOAT_RATIONAL token.
+ * Allocate and initialize a new RationalNode node from a FLOAT_RATIONAL token.
  */
 static pm_rational_node_t *
 pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
@@ -4300,16 +4300,44 @@ pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
     *node = (pm_rational_node_t) {
         {
             .type = PM_RATIONAL_NODE,
-            .flags = PM_NODE_FLAG_STATIC_LITERAL,
+            .flags = PM_INTEGER_BASE_FLAGS_DECIMAL | PM_NODE_FLAG_STATIC_LITERAL,
             .location = PM_LOCATION_TOKEN_VALUE(token)
         },
-        .numeric = (pm_node_t *) pm_float_node_create(parser, &((pm_token_t) {
-            .type = PM_TOKEN_FLOAT,
-            .start = token->start,
-            .end = token->end - 1
-        }))
+        .numerator = { 0 },
+        .denominator = { 0 }
     };
 
+    const uint8_t *start = token->start;
+    const uint8_t *end = token->end - 1; // r
+
+    while (start < end && *start == '0') start++; // 0.1 -> .1
+    while (end > start && end[-1] == '0') end--; // 1.0 -> 1.
+
+    size_t length = (size_t) (end - start);
+    if (length == 1) {
+        node->denominator.value = 1;
+        return node;
+    }
+
+    const uint8_t *point = memchr(start, '.', length);
+    assert(point && "should have a decimal point");
+
+    uint8_t *digits = malloc(length - 1);
+    if (digits == NULL) {
+        fputs("[pm_float_node_rational_create] Failed to allocate memory", stderr);
+        abort();
+    }
+
+    memcpy(digits, start, (unsigned long) (point - start));
+    memcpy(digits + (point - start), point + 1, (unsigned long) (end - point - 1));
+    pm_integer_parse(&node->numerator, PM_INTEGER_BASE_DEFAULT, digits, digits + length - 1);
+
+    digits[0] = '1';
+    memset(digits + 1, '0', (size_t) (end - point - 1));
+    pm_integer_parse(&node->denominator, PM_INTEGER_BASE_DEFAULT, digits, digits + (end - point));
+    free(digits);
+
+    pm_integers_reduce(&node->numerator, &node->denominator);
     return node;
 }
 
@@ -4943,7 +4971,7 @@ pm_integer_node_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, cons
 }
 
 /**
- * Allocate and initialize a new IntegerNode node from an INTEGER_RATIONAL
+ * Allocate and initialize a new RationalNode node from an INTEGER_RATIONAL
  * token.
  */
 static pm_rational_node_t *
@@ -4954,16 +4982,24 @@ pm_integer_node_rational_create(pm_parser_t *parser, pm_node_flags_t base, const
     *node = (pm_rational_node_t) {
         {
             .type = PM_RATIONAL_NODE,
-            .flags = PM_NODE_FLAG_STATIC_LITERAL,
+            .flags = base | PM_NODE_FLAG_STATIC_LITERAL,
             .location = PM_LOCATION_TOKEN_VALUE(token)
         },
-        .numeric = (pm_node_t *) pm_integer_node_create(parser, base, &((pm_token_t) {
-            .type = PM_TOKEN_INTEGER,
-            .start = token->start,
-            .end = token->end - 1
-        }))
+        .numerator = { 0 },
+        .denominator = { .value = 1, 0 }
     };
 
+    pm_integer_base_t integer_base = PM_INTEGER_BASE_DECIMAL;
+    switch (base) {
+        case PM_INTEGER_BASE_FLAGS_BINARY: integer_base = PM_INTEGER_BASE_BINARY; break;
+        case PM_INTEGER_BASE_FLAGS_OCTAL: integer_base = PM_INTEGER_BASE_OCTAL; break;
+        case PM_INTEGER_BASE_FLAGS_DECIMAL: break;
+        case PM_INTEGER_BASE_FLAGS_HEXADECIMAL: integer_base = PM_INTEGER_BASE_HEXADECIMAL; break;
+        default: assert(false && "unreachable"); break;
+    }
+
+    pm_integer_parse(&node->numerator, integer_base, token->start, token->end - 1);
+
     return node;
 }
 
@@ -16887,10 +16923,12 @@ parse_negative_numeric(pm_node_t *node) {
             cast->value = -cast->value;
             break;
         }
-        case PM_RATIONAL_NODE:
-            node->location.start--;
-            parse_negative_numeric(((pm_rational_node_t *) node)->numeric);
+        case PM_RATIONAL_NODE: {
+            pm_rational_node_t *cast = (pm_rational_node_t *) node;
+            cast->base.location.start--;
+            cast->numerator.negative = true;
             break;
+        }
         case PM_IMAGINARY_NODE:
             node->location.start--;
             parse_negative_numeric(((pm_imaginary_node_t *) node)->numeric);
diff --git a/prism/static_literals.c b/prism/static_literals.c
index 08f61c81fa1607..754a2d26b4a9e7 100644
--- a/prism/static_literals.c
+++ b/prism/static_literals.c
@@ -58,6 +58,25 @@ murmur_hash(const uint8_t *key, size_t length) {
     return hash;
 }
 
+/**
+ * Hash the value of an integer and return it.
+ */
+static uint32_t
+integer_hash(const pm_integer_t *integer) {
+    uint32_t hash;
+    if (integer->values) {
+        hash = murmur_hash((const uint8_t *) integer->values, sizeof(uint32_t) * integer->length);
+    } else {
+        hash = murmur_hash((const uint8_t *) &integer->value, sizeof(uint32_t));
+    }
+
+    if (integer->negative) {
+        hash ^= murmur_scramble((uint32_t) 1);
+    }
+
+    return hash;
+}
+
 /**
  * Return the hash of the given node. It is important that nodes that have
  * equivalent static literal values have the same hash. This is because we use
@@ -68,19 +87,8 @@ node_hash(const pm_static_literals_metadata_t *metadata, const pm_node_t *node)
     switch (PM_NODE_TYPE(node)) {
         case PM_INTEGER_NODE: {
             // Integers hash their value.
-            const pm_integer_t *integer = &((const pm_integer_node_t *) node)->value;
-            uint32_t hash;
-            if (integer->values) {
-                hash = murmur_hash((const uint8_t *) integer->values, sizeof(uint32_t) * integer->length);
-            } else {
-                hash = murmur_hash((const uint8_t *) &integer->value, sizeof(uint32_t));
-            }
-
-            if (integer->negative) {
-                hash ^= murmur_scramble((uint32_t) 1);
-            }
-
-            return hash;
+            const pm_integer_node_t *cast = (const pm_integer_node_t *) node;
+            return integer_hash(&cast->value);
         }
         case PM_SOURCE_LINE_NODE: {
             // Source lines hash their line number.
@@ -94,11 +102,9 @@ node_hash(const pm_static_literals_metadata_t *metadata, const pm_node_t *node)
             return murmur_hash((const uint8_t *) value, sizeof(double));
         }
         case PM_RATIONAL_NODE: {
-            // Rationals hash their numeric value. Because their numeric value
-            // is stored as a subnode, we hash that node and then mix in the
-            // fact that this is a rational node.
-            const pm_node_t *numeric = ((const pm_rational_node_t *) node)->numeric;
-            return node_hash(metadata, numeric) ^ murmur_scramble((uint32_t) node->type);
+            // Rationals hash their numerator and denominator.
+            const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
+            return integer_hash(&cast->numerator) ^ integer_hash(&cast->denominator) ^ murmur_scramble((uint32_t) cast->base.type);
         }
         case PM_IMAGINARY_NODE: {
             // Imaginaries hash their numeric value. Because their numeric value
@@ -275,8 +281,15 @@ pm_compare_number_nodes(const pm_static_literals_metadata_t *metadata, const pm_
     switch (PM_NODE_TYPE(left)) {
         case PM_IMAGINARY_NODE:
             return pm_compare_number_nodes(metadata, ((const pm_imaginary_node_t *) left)->numeric, ((const pm_imaginary_node_t *) right)->numeric);
-        case PM_RATIONAL_NODE:
-            return pm_compare_number_nodes(metadata, ((const pm_rational_node_t *) left)->numeric, ((const pm_rational_node_t *) right)->numeric);
+        case PM_RATIONAL_NODE: {
+            const pm_rational_node_t *left_rational = (const pm_rational_node_t *) left;
+            const pm_rational_node_t *right_rational = (const pm_rational_node_t *) right;
+
+            int result = pm_integer_compare(&left_rational->denominator, &right_rational->denominator);
+            if (result != 0) return result;
+
+            return pm_integer_compare(&left_rational->numerator, &right_rational->numerator);
+        }
         case PM_INTEGER_NODE:
             return pm_compare_integer_nodes(metadata, left, right);
         case PM_FLOAT_NODE:
@@ -456,7 +469,7 @@ pm_static_literal_positive_p(const pm_node_t *node) {
         case PM_INTEGER_NODE:
             return !((const pm_integer_node_t *) node)->value.negative;
         case PM_RATIONAL_NODE:
-            return pm_static_literal_positive_p(((const pm_rational_node_t *) node)->numeric);
+            return !((const pm_rational_node_t *) node)->numerator.negative;
         case PM_IMAGINARY_NODE:
             return pm_static_literal_positive_p(((const pm_imaginary_node_t *) node)->numeric);
         default:
@@ -465,43 +478,6 @@ pm_static_literal_positive_p(const pm_node_t *node) {
     }
 }
 
-/**
- * Inspect a rational node that wraps a float node. This is going to be a
- * poor-man's version of the Ruby `Rational#to_s` method, because we're not
- * going to try to reduce the rational by finding the GCD. We'll leave that for
- * a future improvement.
- */
-static void
-pm_rational_inspect(pm_buffer_t *buffer, pm_rational_node_t *node) {
-    const uint8_t *start = node->base.location.start;
-    const uint8_t *end = node->base.location.end - 1; // r
-
-    while (start < end && *start == '0') start++; // 0.1 -> .1
-    while (end > start && end[-1] == '0') end--; // 1.0 -> 1.
-    size_t length = (size_t) (end - start);
-
-    const uint8_t *point = memchr(start, '.', length);
-    assert(point && "should have a decimal point");
-
-    uint8_t *digits = malloc(length - 1);
-    if (digits == NULL) return;
-
-    memcpy(digits, start, (unsigned long) (point - start));
-    memcpy(digits + (point - start), point + 1, (unsigned long) (end - point - 1));
-
-    pm_integer_t numerator = { 0 };
-    pm_integer_parse(&numerator, PM_INTEGER_BASE_DECIMAL, digits, digits + length - 1);
-
-    pm_buffer_append_byte(buffer, '(');
-    pm_integer_string(buffer, &numerator);
-    pm_buffer_append_string(buffer, "/1", 2);
-    for (size_t index = 0; index < (size_t) (end - point - 1); index++) pm_buffer_append_byte(buffer, '0');
-    pm_buffer_append_byte(buffer, ')');
-
-    pm_integer_free(&numerator);
-    free(digits);
-}
-
 /**
  * Create a string-based representation of the given static literal.
  */
@@ -544,7 +520,9 @@ pm_static_literal_inspect_node(pm_buffer_t *buffer, const pm_static_literals_met
             pm_buffer_append_string(buffer, "(0", 2);
             if (pm_static_literal_positive_p(numeric)) pm_buffer_append_byte(buffer, '+');
             pm_static_literal_inspect_node(buffer, metadata, numeric);
-            if (PM_NODE_TYPE_P(numeric, PM_RATIONAL_NODE)) pm_buffer_append_byte(buffer, '*');
+            if (PM_NODE_TYPE_P(numeric, PM_RATIONAL_NODE)) {
+                pm_buffer_append_byte(buffer, '*');
+            }
             pm_buffer_append_string(buffer, "i)", 2);
             break;
         }
@@ -555,22 +533,12 @@ pm_static_literal_inspect_node(pm_buffer_t *buffer, const pm_static_literals_met
             pm_buffer_append_string(buffer, "nil", 3);
             break;
         case PM_RATIONAL_NODE: {
-            const pm_node_t *numeric = ((const pm_rational_node_t *) node)->numeric;
-
-            switch (PM_NODE_TYPE(numeric)) {
-                case PM_INTEGER_NODE:
-                    pm_buffer_append_byte(buffer, '(');
-                    pm_static_literal_inspect_node(buffer, metadata, numeric);
-                    pm_buffer_append_string(buffer, "/1)", 3);
-                    break;
-                case PM_FLOAT_NODE:
-                    pm_rational_inspect(buffer, (pm_rational_node_t *) node);
-                    break;
-                default:
-                    assert(false && "unreachable");
-                    break;
-            }
-
+            const pm_rational_node_t *rational = (const pm_rational_node_t *) node;
+            pm_buffer_append_byte(buffer, '(');
+            pm_integer_string(buffer, &rational->numerator);
+            pm_buffer_append_byte(buffer, '/');
+            pm_integer_string(buffer, &rational->denominator);
+            pm_buffer_append_byte(buffer, ')');
             break;
         }
         case PM_REGULAR_EXPRESSION_NODE: {
diff --git a/prism/util/pm_integer.c b/prism/util/pm_integer.c
index e523bae90b13da..015789ccecfd1f 100644
--- a/prism/util/pm_integer.c
+++ b/prism/util/pm_integer.c
@@ -473,13 +473,16 @@ pm_integer_parse_big(pm_integer_t *integer, uint32_t multiplier, const uint8_t *
  */
 PRISM_EXPORTED_FUNCTION void
 pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end) {
-    // Ignore unary +. Unary + is parsed differently and will not end up here.
+    // Ignore unary +. Unary - is parsed differently and will not end up here.
     // Instead, it will modify the parsed integer later.
     if (*start == '+') start++;
 
     // Determine the multiplier from the base, and skip past any prefixes.
     uint32_t multiplier = 10;
     switch (base) {
+        case PM_INTEGER_BASE_DEFAULT:
+            while (*start == '0') start++; // 01 -> 1
+            break;
         case PM_INTEGER_BASE_BINARY:
             start += 2; // 0b
             multiplier = 2;
@@ -572,6 +575,39 @@ pm_integer_compare(const pm_integer_t *left, const pm_integer_t *right) {
     return 0;
 }
 
+/**
+ * Reduce a ratio of integers to its simplest form.
+ */
+void pm_integers_reduce(pm_integer_t *numerator, pm_integer_t *denominator) {
+    // If either the numerator or denominator do not fit into a 32-bit integer,
+    // then this function is a no-op. In the future, we may consider reducing
+    // even the larger numbers, but for now we're going to keep it simple.
+    if (
+        // If the numerator doesn't fit into a 32-bit integer, return early.
+        numerator->length != 0 ||
+        // If the denominator doesn't fit into a 32-bit integer, return early.
+        denominator->length != 0 ||
+        // If the numerator is 0, then return early.
+        numerator->value == 0 ||
+        // If the denominator is 1, then return early.
+        denominator->value == 1
+    ) return;
+
+    // Find the greatest common divisor of the numerator and denominator.
+    uint32_t divisor = numerator->value;
+    uint32_t remainder = denominator->value;
+
+    while (remainder != 0) {
+        uint32_t temporary = remainder;
+        remainder = divisor % remainder;
+        divisor = temporary;
+    }
+
+    // Divide the numerator and denominator by the greatest common divisor.
+    numerator->value /= divisor;
+    denominator->value /= divisor;
+}
+
 /**
  * Convert an integer to a decimal string.
  */
diff --git a/prism/util/pm_integer.h b/prism/util/pm_integer.h
index 7f172988b3e182..d2a1808b191336 100644
--- a/prism/util/pm_integer.h
+++ b/prism/util/pm_integer.h
@@ -48,6 +48,9 @@ typedef struct {
  * from the string itself.
  */
 typedef enum {
+    /** The default decimal base, with no prefix. Leading 0s will be ignored. */
+    PM_INTEGER_BASE_DEFAULT,
+
     /** The binary base, indicated by a 0b or 0B prefix. */
     PM_INTEGER_BASE_BINARY,
 
@@ -100,6 +103,18 @@ size_t pm_integer_memsize(const pm_integer_t *integer);
  */
 int pm_integer_compare(const pm_integer_t *left, const pm_integer_t *right);
 
+/**
+ * Reduce a ratio of integers to its simplest form.
+ *
+ * If either the numerator or denominator do not fit into a 32-bit integer, then
+ * this function is a no-op. In the future, we may consider reducing even the
+ * larger numbers, but for now we're going to keep it simple.
+ *
+ * @param numerator The numerator of the ratio.
+ * @param denominator The denominator of the ratio.
+ */
+void pm_integers_reduce(pm_integer_t *numerator, pm_integer_t *denominator);
+
 /**
  * Convert an integer to a decimal string.
  *
diff --git a/test/prism/snapshots/numbers.txt b/test/prism/snapshots/numbers.txt
index 740f3f5a2a1684..58aea454fa0ae0 100644
--- a/test/prism/snapshots/numbers.txt
+++ b/test/prism/snapshots/numbers.txt
@@ -65,52 +65,48 @@
         │       ├── flags: decimal
         │       └── value: 1
         ├── @ RationalNode (location: (41,0)-(41,2))
-        │   └── numeric:
-        │       @ IntegerNode (location: (41,0)-(41,1))
-        │       ├── flags: decimal
-        │       └── value: 1
+        │   ├── flags: decimal
+        │   ├── numerator: 1
+        │   └── denominator: 1
         ├── @ IntegerNode (location: (43,0)-(43,2))
         │   ├── flags: decimal
         │   └── value: -1
         ├── @ ImaginaryNode (location: (45,0)-(45,3))
         │   └── numeric:
         │       @ RationalNode (location: (45,0)-(45,2))
-        │       └── numeric:
-        │           @ IntegerNode (location: (45,0)-(45,1))
-        │           ├── flags: decimal
-        │           └── value: 1
+        │       ├── flags: decimal
+        │       ├── numerator: 1
+        │       └── denominator: 1
         ├── @ RationalNode (location: (47,0)-(47,4))
-        │   └── numeric:
-        │       @ FloatNode (location: (47,0)-(47,3))
-        │       └── value: 1.2
+        │   ├── flags: decimal
+        │   ├── numerator: 6
+        │   └── denominator: 5
         ├── @ ImaginaryNode (location: (49,0)-(49,5))
         │   └── numeric:
         │       @ RationalNode (location: (49,0)-(49,4))
-        │       └── numeric:
-        │           @ FloatNode (location: (49,0)-(49,3))
-        │           └── value: 1.2
+        │       ├── flags: decimal
+        │       ├── numerator: 6
+        │       └── denominator: 5
         ├── @ ImaginaryNode (location: (51,0)-(51,4))
         │   └── numeric:
         │       @ RationalNode (location: (51,0)-(51,3))
-        │       └── numeric:
-        │           @ IntegerNode (location: (51,0)-(51,2))
-        │           ├── flags: decimal
-        │           └── value: -1
+        │       ├── flags: decimal
+        │       ├── numerator: -1
+        │       └── denominator: 1
         ├── @ RationalNode (location: (53,0)-(53,5))
-        │   └── numeric:
-        │       @ FloatNode (location: (53,0)-(53,4))
-        │       └── value: -1.2
+        │   ├── flags: decimal
+        │   ├── numerator: -6
+        │   └── denominator: 5
         ├── @ ImaginaryNode (location: (55,0)-(55,6))
         │   └── numeric:
         │       @ RationalNode (location: (55,0)-(55,5))
-        │       └── numeric:
-        │           @ FloatNode (location: (55,0)-(55,4))
-        │           └── value: -1.2
+        │       ├── flags: decimal
+        │       ├── numerator: -6
+        │       └── denominator: 5
         ├── @ RationalNode (location: (57,0)-(57,4))
-        │   └── numeric:
-        │       @ IntegerNode (location: (57,0)-(57,3))
-        │       ├── flags: octal
-        │       └── value: 1
+        │   ├── flags: octal
+        │   ├── numerator: 1
+        │   └── denominator: 1
         ├── @ ImaginaryNode (location: (59,0)-(59,4))
         │   └── numeric:
         │       @ IntegerNode (location: (59,0)-(59,3))
@@ -119,15 +115,13 @@
         ├── @ ImaginaryNode (location: (61,0)-(61,5))
         │   └── numeric:
         │       @ RationalNode (location: (61,0)-(61,4))
-        │       └── numeric:
-        │           @ IntegerNode (location: (61,0)-(61,3))
-        │           ├── flags: octal
-        │           └── value: 1
+        │       ├── flags: octal
+        │       ├── numerator: 1
+        │       └── denominator: 1
         ├── @ RationalNode (location: (63,0)-(63,4))
-        │   └── numeric:
-        │       @ IntegerNode (location: (63,0)-(63,3))
-        │       ├── flags: decimal
-        │       └── value: 1
+        │   ├── flags: decimal
+        │   ├── numerator: 1
+        │   └── denominator: 1
         ├── @ ImaginaryNode (location: (65,0)-(65,4))
         │   └── numeric:
         │       @ IntegerNode (location: (65,0)-(65,3))
@@ -136,7 +130,6 @@
         └── @ ImaginaryNode (location: (67,0)-(67,5))
             └── numeric:
                 @ RationalNode (location: (67,0)-(67,4))
-                └── numeric:
-                    @ IntegerNode (location: (67,0)-(67,3))
-                    ├── flags: binary
-                    └── value: 1
+                ├── flags: binary
+                ├── numerator: 1
+                └── denominator: 1
diff --git a/test/prism/snapshots/patterns.txt b/test/prism/snapshots/patterns.txt
index 16298e798493d7..17aa23b4b9434e 100644
--- a/test/prism/snapshots/patterns.txt
+++ b/test/prism/snapshots/patterns.txt
@@ -86,10 +86,9 @@
         │   │   └── block: ∅
         │   ├── pattern:
         │   │   @ RationalNode (location: (5,7)-(5,9))
-        │   │   └── numeric:
-        │   │       @ IntegerNode (location: (5,7)-(5,8))
-        │   │       ├── flags: decimal
-        │   │       └── value: 1
+        │   │   ├── flags: decimal
+        │   │   ├── numerator: 1
+        │   │   └── denominator: 1
         │   └── operator_loc: (5,4)-(5,6) = "=>"
         ├── @ MatchRequiredNode (location: (6,0)-(6,11))
         │   ├── value:
@@ -598,16 +597,14 @@
         │   │   ├── flags: ∅
         │   │   ├── left:
         │   │   │   @ RationalNode (location: (31,7)-(31,9))
-        │   │   │   └── numeric:
-        │   │   │       @ IntegerNode (location: (31,7)-(31,8))
-        │   │   │       ├── flags: decimal
-        │   │   │       └── value: 1
+        │   │   │   ├── flags: decimal
+        │   │   │   ├── numerator: 1
+        │   │   │   └── denominator: 1
         │   │   ├── right:
         │   │   │   @ RationalNode (location: (31,13)-(31,15))
-        │   │   │   └── numeric:
-        │   │   │       @ IntegerNode (location: (31,13)-(31,14))
-        │   │   │       ├── flags: decimal
-        │   │   │       └── value: 1
+        │   │   │   ├── flags: decimal
+        │   │   │   ├── numerator: 1
+        │   │   │   └── denominator: 1
         │   │   └── operator_loc: (31,10)-(31,12) = ".."
         │   └── operator_loc: (31,4)-(31,6) = "=>"
         ├── @ MatchRequiredNode (location: (32,0)-(32,19))
@@ -2461,10 +2458,9 @@
         │   │   └── block: ∅
         │   ├── pattern:
         │   │   @ RationalNode (location: (108,7)-(108,9))
-        │   │   └── numeric:
-        │   │       @ IntegerNode (location: (108,7)-(108,8))
-        │   │       ├── flags: decimal
-        │   │       └── value: 1
+        │   │   ├── flags: decimal
+        │   │   ├── numerator: 1
+        │   │   └── denominator: 1
         │   └── operator_loc: (108,4)-(108,6) = "in"
         ├── @ MatchPredicateNode (location: (109,0)-(109,11))
         │   ├── value:
@@ -3017,10 +3013,9 @@
         │   │   └── @ InNode (location: (139,10)-(139,20))
         │   │       ├── pattern:
         │   │       │   @ RationalNode (location: (139,13)-(139,15))
-        │   │       │   └── numeric:
-        │   │       │       @ IntegerNode (location: (139,13)-(139,14))
-        │   │       │       ├── flags: decimal
-        │   │       │       └── value: 1
+        │   │       │   ├── flags: decimal
+        │   │       │   ├── numerator: 1
+        │   │       │   └── denominator: 1
         │   │       ├── statements: ∅
         │   │       ├── in_loc: (139,10)-(139,12) = "in"
         │   │       └── then_loc: (139,16)-(139,20) = "then"
@@ -3758,10 +3753,9 @@
         │   │       │   │   @ StatementsNode (location: (166,13)-(166,15))
         │   │       │   │   └── body: (length: 1)
         │   │       │   │       └── @ RationalNode (location: (166,13)-(166,15))
-        │   │       │   │           └── numeric:
-        │   │       │   │               @ IntegerNode (location: (166,13)-(166,14))
-        │   │       │   │               ├── flags: decimal
-        │   │       │   │               └── value: 1
+        │   │       │   │           ├── flags: decimal
+        │   │       │   │           ├── numerator: 1
+        │   │       │   │           └── denominator: 1
         │   │       │   ├── consequent: ∅
         │   │       │   └── end_keyword_loc: ∅
         │   │       ├── statements: ∅
diff --git a/test/prism/snapshots/seattlerb/ruby21_numbers.txt b/test/prism/snapshots/seattlerb/ruby21_numbers.txt
index 34a3452d1b3539..e7eec943f827c8 100644
--- a/test/prism/snapshots/seattlerb/ruby21_numbers.txt
+++ b/test/prism/snapshots/seattlerb/ruby21_numbers.txt
@@ -12,16 +12,14 @@
             │   │       ├── flags: decimal
             │   │       └── value: 1
             │   ├── @ RationalNode (location: (1,5)-(1,7))
-            │   │   └── numeric:
-            │   │       @ IntegerNode (location: (1,5)-(1,6))
-            │   │       ├── flags: decimal
-            │   │       └── value: 2
+            │   │   ├── flags: decimal
+            │   │   ├── numerator: 2
+            │   │   └── denominator: 1
             │   └── @ ImaginaryNode (location: (1,9)-(1,12))
             │       └── numeric:
             │           @ RationalNode (location: (1,9)-(1,11))
-            │           └── numeric:
-            │               @ IntegerNode (location: (1,9)-(1,10))
-            │               ├── flags: decimal
-            │               └── value: 3
+            │           ├── flags: decimal
+            │           ├── numerator: 3
+            │           └── denominator: 1
             ├── opening_loc: (1,0)-(1,1) = "["
             └── closing_loc: (1,12)-(1,13) = "]"
diff --git a/test/prism/snapshots/symbols.txt b/test/prism/snapshots/symbols.txt
index dbd3a4d030d8f0..48ff0d634fabd1 100644
--- a/test/prism/snapshots/symbols.txt
+++ b/test/prism/snapshots/symbols.txt
@@ -146,10 +146,9 @@
         │   │   ├── @ FloatNode (location: (29,4)-(29,7))
         │   │   │   └── value: 1.0
         │   │   ├── @ RationalNode (location: (29,9)-(29,11))
-        │   │   │   └── numeric:
-        │   │   │       @ IntegerNode (location: (29,9)-(29,10))
-        │   │   │       ├── flags: decimal
-        │   │   │       └── value: 1
+        │   │   │   ├── flags: decimal
+        │   │   │   ├── numerator: 1
+        │   │   │   └── denominator: 1
         │   │   └── @ ImaginaryNode (location: (29,13)-(29,15))
         │   │       └── numeric:
         │   │           @ IntegerNode (location: (29,13)-(29,14))
diff --git a/test/prism/snapshots/unparser/corpus/literal/literal.txt b/test/prism/snapshots/unparser/corpus/literal/literal.txt
index 98b88e11cebdd3..ddb10456bf0a7a 100644
--- a/test/prism/snapshots/unparser/corpus/literal/literal.txt
+++ b/test/prism/snapshots/unparser/corpus/literal/literal.txt
@@ -316,18 +316,17 @@
         │   ├── flags: decimal
         │   └── value: 1
         ├── @ RationalNode (location: (19,0)-(19,2))
-        │   └── numeric:
-        │       @ IntegerNode (location: (19,0)-(19,1))
-        │       ├── flags: decimal
-        │       └── value: 1
+        │   ├── flags: decimal
+        │   ├── numerator: 1
+        │   └── denominator: 1
         ├── @ RationalNode (location: (20,0)-(20,4))
-        │   └── numeric:
-        │       @ FloatNode (location: (20,0)-(20,3))
-        │       └── value: 1.5
+        │   ├── flags: decimal
+        │   ├── numerator: 3
+        │   └── denominator: 2
         ├── @ RationalNode (location: (21,0)-(21,4))
-        │   └── numeric:
-        │       @ FloatNode (location: (21,0)-(21,3))
-        │       └── value: 1.3
+        │   ├── flags: decimal
+        │   ├── numerator: 13
+        │   └── denominator: 10
         ├── @ ImaginaryNode (location: (22,0)-(22,2))
         │   └── numeric:
         │       @ IntegerNode (location: (22,0)-(22,1))
@@ -354,10 +353,9 @@
         ├── @ ImaginaryNode (location: (27,0)-(27,3))
         │   └── numeric:
         │       @ RationalNode (location: (27,0)-(27,2))
-        │       └── numeric:
-        │           @ IntegerNode (location: (27,0)-(27,1))
-        │           ├── flags: decimal
-        │           └── value: 1
+        │       ├── flags: decimal
+        │       ├── numerator: 1
+        │       └── denominator: 1
         ├── @ InterpolatedStringNode (location: (28,0)-(28,11))
         │   ├── flags: ∅
         │   ├── opening_loc: ∅
diff --git a/test/prism/snapshots/unparser/corpus/semantic/literal.txt b/test/prism/snapshots/unparser/corpus/semantic/literal.txt
index ef666890be7d34..448207f5d37bc4 100644
--- a/test/prism/snapshots/unparser/corpus/semantic/literal.txt
+++ b/test/prism/snapshots/unparser/corpus/semantic/literal.txt
@@ -4,14 +4,13 @@
     @ StatementsNode (location: (1,0)-(14,10))
     └── body: (length: 14)
         ├── @ RationalNode (location: (1,0)-(1,4))
-        │   └── numeric:
-        │       @ FloatNode (location: (1,0)-(1,3))
-        │       └── value: 1.0
+        │   ├── flags: decimal
+        │   ├── numerator: 1
+        │   └── denominator: 1
         ├── @ RationalNode (location: (2,0)-(2,3))
-        │   └── numeric:
-        │       @ IntegerNode (location: (2,0)-(2,2))
-        │       ├── flags: decimal
-        │       └── value: 0
+        │   ├── flags: decimal
+        │   ├── numerator: 0
+        │   └── denominator: 1
         ├── @ IntegerNode (location: (3,0)-(3,3))
         │   ├── flags: hexadecimal
         │   └── value: 1
diff --git a/test/prism/snapshots/whitequark/complex.txt b/test/prism/snapshots/whitequark/complex.txt
index e688585a5f9f2f..bc748db09bb969 100644
--- a/test/prism/snapshots/whitequark/complex.txt
+++ b/test/prism/snapshots/whitequark/complex.txt
@@ -10,9 +10,9 @@
         ├── @ ImaginaryNode (location: (3,0)-(3,6))
         │   └── numeric:
         │       @ RationalNode (location: (3,0)-(3,5))
-        │       └── numeric:
-        │           @ FloatNode (location: (3,0)-(3,4))
-        │           └── value: 42.1
+        │       ├── flags: decimal
+        │       ├── numerator: 421
+        │       └── denominator: 10
         ├── @ ImaginaryNode (location: (5,0)-(5,3))
         │   └── numeric:
         │       @ IntegerNode (location: (5,0)-(5,2))
@@ -21,7 +21,6 @@
         └── @ ImaginaryNode (location: (7,0)-(7,4))
             └── numeric:
                 @ RationalNode (location: (7,0)-(7,3))
-                └── numeric:
-                    @ IntegerNode (location: (7,0)-(7,2))
-                    ├── flags: decimal
-                    └── value: 42
+                ├── flags: decimal
+                ├── numerator: 42
+                └── denominator: 1
diff --git a/test/prism/snapshots/whitequark/rational.txt b/test/prism/snapshots/whitequark/rational.txt
index 90bbd17929b031..e8c8eed5082799 100644
--- a/test/prism/snapshots/whitequark/rational.txt
+++ b/test/prism/snapshots/whitequark/rational.txt
@@ -4,11 +4,10 @@
     @ StatementsNode (location: (1,0)-(3,3))
     └── body: (length: 2)
         ├── @ RationalNode (location: (1,0)-(1,5))
-        │   └── numeric:
-        │       @ FloatNode (location: (1,0)-(1,4))
-        │       └── value: 42.1
+        │   ├── flags: decimal
+        │   ├── numerator: 421
+        │   └── denominator: 10
         └── @ RationalNode (location: (3,0)-(3,3))
-            └── numeric:
-                @ IntegerNode (location: (3,0)-(3,2))
-                ├── flags: decimal
-                └── value: 42
+            ├── flags: decimal
+            ├── numerator: 42
+            └── denominator: 1
diff --git a/test/prism/snapshots/whitequark/ruby_bug_11873_a.txt b/test/prism/snapshots/whitequark/ruby_bug_11873_a.txt
index 93418e64483f98..831d57e30d38e3 100644
--- a/test/prism/snapshots/whitequark/ruby_bug_11873_a.txt
+++ b/test/prism/snapshots/whitequark/ruby_bug_11873_a.txt
@@ -225,9 +225,9 @@
         │   │       │   ├── closing_loc: (7,7)-(7,8) = ")"
         │   │       │   └── block: ∅
         │   │       └── @ RationalNode (location: (7,10)-(7,14))
-        │   │           └── numeric:
-        │   │               @ FloatNode (location: (7,10)-(7,13))
-        │   │               └── value: 1.0
+        │   │           ├── flags: decimal
+        │   │           ├── numerator: 1
+        │   │           └── denominator: 1
         │   ├── closing_loc: ∅
         │   └── block:
         │       @ BlockNode (location: (7,15)-(7,21))
@@ -519,9 +519,9 @@
         │   │       │   ├── closing_loc: (17,8)-(17,9) = ")"
         │   │       │   └── block: ∅
         │   │       └── @ RationalNode (location: (17,11)-(17,15))
-        │   │           └── numeric:
-        │   │               @ FloatNode (location: (17,11)-(17,14))
-        │   │               └── value: 1.0
+        │   │           ├── flags: decimal
+        │   │           ├── numerator: 1
+        │   │           └── denominator: 1
         │   ├── closing_loc: ∅
         │   └── block:
         │       @ BlockNode (location: (17,16)-(17,22))
@@ -833,9 +833,9 @@
         │   │       │       ├── opening_loc: (27,3)-(27,4) = "{"
         │   │       │       └── closing_loc: (27,7)-(27,8) = "}"
         │   │       └── @ RationalNode (location: (27,10)-(27,14))
-        │   │           └── numeric:
-        │   │               @ FloatNode (location: (27,10)-(27,13))
-        │   │               └── value: 1.0
+        │   │           ├── flags: decimal
+        │   │           ├── numerator: 1
+        │   │           └── denominator: 1
         │   ├── closing_loc: ∅
         │   └── block:
         │       @ BlockNode (location: (27,15)-(27,21))
@@ -1152,9 +1152,9 @@
         │   │       │       ├── opening_loc: (37,3)-(37,4) = "{"
         │   │       │       └── closing_loc: (37,8)-(37,9) = "}"
         │   │       └── @ RationalNode (location: (37,11)-(37,15))
-        │   │           └── numeric:
-        │   │               @ FloatNode (location: (37,11)-(37,14))
-        │   │               └── value: 1.0
+        │   │           ├── flags: decimal
+        │   │           ├── numerator: 1
+        │   │           └── denominator: 1
         │   ├── closing_loc: ∅
         │   └── block:
         │       @ BlockNode (location: (37,16)-(37,22))

From 7a8f797cd4bf7bec1c6d9cba48971b63b1cb839c Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 11:53:24 -0400
Subject: [PATCH 141/242] [PRISM] Use new rational layout

---
 prism_compile.c | 47 ++++++++++++++---------------------------------
 1 file changed, 14 insertions(+), 33 deletions(-)

diff --git a/prism_compile.c b/prism_compile.c
index 18f1d38b7dcec1..b6e43d37f68831 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -152,12 +152,11 @@ pm_location_line_number(const pm_parser_t *parser, const pm_location_t *location
 }
 
 /**
- * Convert the value of an integer node into a Ruby Integer.
+ * Parse the value of a pm_integer_t into a Ruby Integer.
  */
 static VALUE
-parse_integer(const pm_integer_node_t *node)
+parse_integer_value(const pm_integer_t *integer)
 {
-    const pm_integer_t *integer = &node->value;
     VALUE result;
 
     if (integer->values == NULL) {
@@ -187,6 +186,15 @@ parse_integer(const pm_integer_node_t *node)
     return result;
 }
 
+/**
+ * Convert the value of an integer node into a Ruby Integer.
+ */
+static inline VALUE
+parse_integer(const pm_integer_node_t *node)
+{
+    return parse_integer_value(&node->value);
+}
+
 /**
  * Convert the value of a float node into a Ruby Float.
  */
@@ -205,36 +213,9 @@ parse_float(const pm_float_node_t *node)
 static VALUE
 parse_rational(const pm_rational_node_t *node)
 {
-    VALUE result;
-
-    if (PM_NODE_TYPE_P(node->numeric, PM_FLOAT_NODE)) {
-        const uint8_t *start = node->base.location.start;
-        const uint8_t *end = node->base.location.end - 1;
-        size_t length = end - start;
-
-        char *buffer = malloc(length + 1);
-        memcpy(buffer, start, length);
-
-        buffer[length] = '\0';
-
-        char *decimal = memchr(buffer, '.', length);
-        RUBY_ASSERT(decimal);
-        size_t seen_decimal = decimal - buffer;
-        size_t fraclen = length - seen_decimal - 1;
-        memmove(decimal, decimal + 1, fraclen + 1);
-
-        VALUE numerator = rb_cstr_to_inum(buffer, 10, false);
-        result = rb_rational_new(numerator, rb_int_positive_pow(10, fraclen));
-
-        free(buffer);
-    }
-    else {
-        RUBY_ASSERT(PM_NODE_TYPE_P(node->numeric, PM_INTEGER_NODE));
-        VALUE numerator = parse_integer((const pm_integer_node_t *) node->numeric);
-        result = rb_rational_raw(numerator, INT2FIX(1));
-    }
-
-    return result;
+    VALUE numerator = parse_integer_value(&node->numerator);
+    VALUE denominator = parse_integer_value(&node->denominator);
+    return rb_rational_new(numerator, denominator);
 }
 
 /**

From 12386d36f072527cbd623aabd4df9948cf46c616 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 14:33:37 -0400
Subject: [PATCH 142/242] [ruby/prism] Provide deprecated numeric method

https://github.com/ruby/prism/commit/77bf9038a2
---
 lib/prism/node_ext.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/lib/prism/node_ext.rb b/lib/prism/node_ext.rb
index 4761e5b9b27223..cdc4b2bf089ed5 100644
--- a/lib/prism/node_ext.rb
+++ b/lib/prism/node_ext.rb
@@ -105,6 +105,18 @@ class RationalNode < Node
     def value
       Rational(numerator, denominator)
     end
+
+    # Returns the value of the node as an IntegerNode or a FloatNode. This
+    # method is deprecated in favor of #value or #numerator/#denominator.
+    def numeric
+      deprecated("value", "numerator", "denominator")
+
+      if denominator == 1
+        IntegerNode.new(source, flags, numerator, location.chop)
+      else
+        FloatNode.new(source, numerator.to_f / denominator, location.chop)
+      end
+    end
   end
 
   class ConstantReadNode < Node

From b20adf90e3c195098b8a6c36cd4a048592f56366 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 21 May 2024 11:02:59 -0400
Subject: [PATCH 143/242] [ruby/prism] Fix up ruby_parser interpolation
 concatenation

https://github.com/ruby/prism/commit/79cec4be22
---
 lib/prism/translation/ruby_parser.rb | 9 +++++++--
 test/prism/ruby_parser_test.rb       | 6 ------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/lib/prism/translation/ruby_parser.rb b/lib/prism/translation/ruby_parser.rb
index 43aac23be7b7dd..6e745a9041b0aa 100644
--- a/lib/prism/translation/ruby_parser.rb
+++ b/lib/prism/translation/ruby_parser.rb
@@ -905,8 +905,13 @@ def visit_interpolated_x_string_node(node)
                 results << result
                 state = :interpolated_content
               end
-            else
-              results << result
+            when :interpolated_content
+              if result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
+                results[-1][1] << result[1]
+                results[-1].line_max = result.line_max
+              else
+                results << result
+              end
             end
           end
         end
diff --git a/test/prism/ruby_parser_test.rb b/test/prism/ruby_parser_test.rb
index 8edeac4b4f8cbc..b4afff078220dc 100644
--- a/test/prism/ruby_parser_test.rb
+++ b/test/prism/ruby_parser_test.rb
@@ -28,19 +28,15 @@ class RubyParserTest < TestCase
     base = File.join(__dir__, "fixtures")
 
     todos = %w[
-      heredocs_nested.txt
       newline_terminated.txt
       regex_char_width.txt
       seattlerb/bug169.txt
-      seattlerb/dstr_evstr.txt
-      seattlerb/heredoc_squiggly_interp.txt
       seattlerb/masgn_colon3.txt
       seattlerb/messy_op_asgn_lineno.txt
       seattlerb/op_asgn_primary_colon_const_command_call.txt
       seattlerb/parse_line_evstr_after_break.txt
       seattlerb/regexp_esc_C_slash.txt
       seattlerb/str_lit_concat_bad_encodings.txt
-      seattlerb/str_pct_nested_nested.txt
       unescaping.txt
       unparser/corpus/literal/kwbegin.txt
       unparser/corpus/literal/send.txt
@@ -76,12 +72,10 @@ class RubyParserTest < TestCase
       tilde_heredocs.txt
       unparser/corpus/literal/literal.txt
       while.txt
-      whitequark/class_definition_in_while_cond.txt
       whitequark/cond_eflipflop.txt
       whitequark/cond_iflipflop.txt
       whitequark/cond_match_current_line.txt
       whitequark/dedenting_heredoc.txt
-      whitequark/if_while_after_class__since_32.txt
       whitequark/lvar_injecting_match.txt
       whitequark/not.txt
       whitequark/numparam_ruby_bug_19025.txt

From f8e675221917601e22c4465ec37b7f2352e6dce8 Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Wed, 22 May 2024 10:45:02 +0900
Subject: [PATCH 144/242] Revert "[Bug #20499] Use consistent version tools
 with CC"

This reverts commit 8277cf0799145bed0c813bfcc187739f77b3102d.

This change break to build with `rbenv install ruby-dev` with the following error.

```
touch yjit/target/release/libyjit.a
transdb.h updated
./tool/darwin-ar: line 6: /nm: No such file or directory
./tool/darwin-ar: line 6: exec: /nm: cannot execute: No such file or directory
partial linking yjit/target/release/libyjit.a into yjit/target/release/libyjit.o
```
---
 configure.ac | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/configure.ac b/configure.ac
index 169662ca93cf0b..d787bc3502eb71 100644
--- a/configure.ac
+++ b/configure.ac
@@ -248,16 +248,10 @@ AS_CASE(["${build_os}"],
     AC_PATH_TOOL([NM], [nm], [/usr/ccs/bin/nm], [/usr/ccs/bin:$PATH])
 ],
 [darwin*], [
-    # As Apple Xcode is relocatable and selectable with `xcode-select`,
-    # use consistent versions of commands in the same location.
-    AC_MSG_CHECKING([Xcode tools])
-    AS_CASE([$ac_cv_prog_ac_ct_CC],
-        [/*], [],
-        [ac_cv_prog_ac_ct_CC=`command -v $ac_cv_prog_ac_ct_CC`])
-    AC_MSG_RESULT(CC=$ac_cv_prog_ac_ct_CC)
-    ac_cv_prog_ac_ct_AR=${ac_cv_prog_ac_ct_CC%/*}/ar
-    ac_cv_prog_ac_ct_LD=${ac_cv_prog_ac_ct_CC%/*}/ld
-    ac_cv_prog_ac_ct_NM=${ac_cv_prog_ac_ct_CC%/*}/nm
+    # For Apple clang version 14.0.3 (clang-1403.0.22.14.1)
+    ac_cv_prog_ac_ct_AR=`$CC -print-prog-name=ar`
+    ac_cv_prog_ac_ct_LD=`$CC -print-prog-name=ld`
+    ac_cv_prog_ac_ct_NM=`$CC -print-prog-name=nm`
 ])
 AS_CASE(["${target_os}"],
 [cygwin*|msys*|mingw*|darwin*], [

From ae07c606b56881494bb4ff7a46609eab7f418a24 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 22 May 2024 02:24:42 +0000
Subject: [PATCH 145/242] --- updated-dependencies: - dependency-name:
 ruby/setup-ruby   dependency-type: direct:production   update-type:
 version-update:semver-minor ...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/annocheck.yml          | 2 +-
 .github/workflows/baseruby.yml           | 2 +-
 .github/workflows/check_dependencies.yml | 2 +-
 .github/workflows/mingw.yml              | 2 +-
 .github/workflows/rjit-bindgen.yml       | 2 +-
 .github/workflows/spec_guards.yml        | 2 +-
 .github/workflows/ubuntu.yml             | 2 +-
 .github/workflows/wasm.yml               | 2 +-
 .github/workflows/windows.yml            | 2 +-
 .github/workflows/yjit-ubuntu.yml        | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/annocheck.yml b/.github/workflows/annocheck.yml
index 6c03f52289199f..252c587580e6e2 100644
--- a/.github/workflows/annocheck.yml
+++ b/.github/workflows/annocheck.yml
@@ -74,7 +74,7 @@ jobs:
           builddir: build
           makeup: true
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/baseruby.yml b/.github/workflows/baseruby.yml
index ce979c9e7a8c1a..4cec3955a3ebcb 100644
--- a/.github/workflows/baseruby.yml
+++ b/.github/workflows/baseruby.yml
@@ -51,7 +51,7 @@ jobs:
           - ruby-3.3
 
     steps:
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler: none
diff --git a/.github/workflows/check_dependencies.yml b/.github/workflows/check_dependencies.yml
index 8ecae4f2236443..5988947c489693 100644
--- a/.github/workflows/check_dependencies.yml
+++ b/.github/workflows/check_dependencies.yml
@@ -55,7 +55,7 @@ jobs:
 
       - uses: ./.github/actions/setup/directories
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/mingw.yml b/.github/workflows/mingw.yml
index 4170369def04de..90ef5281a3cea0 100644
--- a/.github/workflows/mingw.yml
+++ b/.github/workflows/mingw.yml
@@ -66,7 +66,7 @@ jobs:
 
     steps:
       - name: Set up Ruby & MSYS2
-        uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+        uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: ${{ matrix.baseruby }}
 
diff --git a/.github/workflows/rjit-bindgen.yml b/.github/workflows/rjit-bindgen.yml
index c4cfe9ed83c0de..5b4eee43a1a1f8 100644
--- a/.github/workflows/rjit-bindgen.yml
+++ b/.github/workflows/rjit-bindgen.yml
@@ -47,7 +47,7 @@ jobs:
 
     steps:
       - name: Set up Ruby
-        uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+        uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.1'
 
diff --git a/.github/workflows/spec_guards.yml b/.github/workflows/spec_guards.yml
index 14669a13b3c848..a084b570ebb73a 100644
--- a/.github/workflows/spec_guards.yml
+++ b/.github/workflows/spec_guards.yml
@@ -47,7 +47,7 @@ jobs:
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler: none
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index 697056df604751..f11a96e5d35952 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -67,7 +67,7 @@ jobs:
         with:
           arch: ${{ matrix.arch }}
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/wasm.yml b/.github/workflows/wasm.yml
index 764ca2d21ce8f3..d5f76b0e7ce005 100644
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -100,7 +100,7 @@ jobs:
         run: |
           echo "WASI_SDK_PATH=/opt/wasi-sdk" >> $GITHUB_ENV
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index fcf600263bb84c..38504f78d6a6d2 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -91,7 +91,7 @@ jobs:
             ${{ steps.find-tools.outputs.needs }}
         if: ${{ steps.find-tools.outputs.needs != '' }}
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/yjit-ubuntu.yml b/.github/workflows/yjit-ubuntu.yml
index bd7e25a9cd62a2..a33a1c3c5d792b 100644
--- a/.github/workflows/yjit-ubuntu.yml
+++ b/.github/workflows/yjit-ubuntu.yml
@@ -147,7 +147,7 @@ jobs:
         if: ${{ matrix.rust_version }}
         run: rustup install ${{ matrix.rust_version }} --profile minimal
 
-      - uses: ruby/setup-ruby@cacc9f1c0b3f4eb8a16a6bb0ed10897b43b9de49 # v1.176.0
+      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
         with:
           ruby-version: '3.0'
           bundler: none

From 911b7d1dcfdb613ea5f648bd59bc6e29f9d54c49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladimir=20T=C3=A1mara=20Pati=C3=B1o?=
 <vtamara@pasosdeJesus.org>
Date: Wed, 22 May 2024 00:16:38 -0400
Subject: [PATCH 146/242] [ruby/reline] Catches Errno::ENODEV and Errno::EBADF
 in get_screen_size. Closes https://github.com/ruby/reline/pull/690
 (https://github.com/ruby/reline/pull/702)

* Catches exceptions Errno::ENODEV and Errno::EBADF in get_screen_size. Closes https://github.com/ruby/reline/pull/690

* Just catching Errno::ENOTTY and Errno::ENODEV

https://github.com/ruby/reline/commit/a5b5298e4a
---
 lib/reline/ansi.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/reline/ansi.rb b/lib/reline/ansi.rb
index 45a475a787a582..fa9feb2630d553 100644
--- a/lib/reline/ansi.rb
+++ b/lib/reline/ansi.rb
@@ -235,7 +235,7 @@ def self.get_screen_size
     s = [ENV["LINES"].to_i, ENV["COLUMNS"].to_i]
     return s if s[0] > 0 && s[1] > 0
     [24, 80]
-  rescue Errno::ENOTTY
+  rescue Errno::ENOTTY, Errno::ENODEV
     [24, 80]
   end
 

From 1e08a9f0e9058186db18f29efc6458c00f10a856 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Wed, 22 May 2024 12:29:01 +0900
Subject: [PATCH 147/242] [Bug #20499] Use Xcode owned tools for Xcode clang

Xcode has its own version tools that may be incompatible with genuine
LLVM tools, use the tools in the same directory.
---
 configure.ac | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/configure.ac b/configure.ac
index d787bc3502eb71..ef9a2b324799a4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -227,15 +227,23 @@ AS_CASE(["/${rb_CC} "],
 [*clang*],            [
     # Ditto for LLVM.  Note however that llvm-as is a LLVM-IR to LLVM bitcode
     # assembler that does not target your machine native binary.
+
+    # Xcode has its own version tools that may be incompatible with
+    # genuine LLVM tools, use the tools in the same directory.
+
+    AS_IF([$rb_CC -E -dM -xc - < /dev/null | grep -F __apple_build_version__ > /dev/null],
+          [llvm_prefix=], [llvm_prefix=llvm-])
+    # AC_PREPROC_IFELSE cannot be used before AC_USE_SYSTEM_EXTENSIONS
+
     RUBY_CHECK_PROG_FOR_CC([LD],      [s/clang/ld/]) # ... maybe try lld ?
-    RUBY_CHECK_PROG_FOR_CC([AR],      [s/clang/llvm-ar/])
-#   RUBY_CHECK_PROG_FOR_CC([AS],      [s/clang/llvm-as/])
+    RUBY_CHECK_PROG_FOR_CC([AR],      [s/clang/${llvm_prefix}ar/])
+#   RUBY_CHECK_PROG_FOR_CC([AS],      [s/clang/${llvm_prefix}as/])
     RUBY_CHECK_PROG_FOR_CC([CXX],     [s/clang/clang++/])
-    RUBY_CHECK_PROG_FOR_CC([NM],      [s/clang/llvm-nm/])
-    RUBY_CHECK_PROG_FOR_CC([OBJCOPY], [s/clang/llvm-objcopy/])
-    RUBY_CHECK_PROG_FOR_CC([OBJDUMP], [s/clang/llvm-objdump/])
-    RUBY_CHECK_PROG_FOR_CC([RANLIB],  [s/clang/llvm-ranlib/])
-    RUBY_CHECK_PROG_FOR_CC([STRIP],   [s/clang/llvm-strip/])
+    RUBY_CHECK_PROG_FOR_CC([NM],      [s/clang/${llvm_prefix}nm/])
+    RUBY_CHECK_PROG_FOR_CC([OBJCOPY], [s/clang/${llvm_prefix}objcopy/])
+    RUBY_CHECK_PROG_FOR_CC([OBJDUMP], [s/clang/${llvm_prefix}objdump/])
+    RUBY_CHECK_PROG_FOR_CC([RANLIB],  [s/clang/${llvm_prefix}ranlib/])
+    RUBY_CHECK_PROG_FOR_CC([STRIP],   [s/clang/${llvm_prefix}strip/])
 ])
 AS_UNSET(rb_CC)
 AS_UNSET(rb_dummy)
@@ -246,12 +254,6 @@ AS_CASE(["${build_os}"],
 ],
 [aix*], [
     AC_PATH_TOOL([NM], [nm], [/usr/ccs/bin/nm], [/usr/ccs/bin:$PATH])
-],
-[darwin*], [
-    # For Apple clang version 14.0.3 (clang-1403.0.22.14.1)
-    ac_cv_prog_ac_ct_AR=`$CC -print-prog-name=ar`
-    ac_cv_prog_ac_ct_LD=`$CC -print-prog-name=ld`
-    ac_cv_prog_ac_ct_NM=`$CC -print-prog-name=nm`
 ])
 AS_CASE(["${target_os}"],
 [cygwin*|msys*|mingw*|darwin*], [

From ec9de0c4717b2942edba560b510a170f812a2f2c Mon Sep 17 00:00:00 2001
From: Ellen Keal <ekeal@mpr.org>
Date: Fri, 10 May 2024 15:26:41 -0500
Subject: [PATCH 148/242] [rubygems/rubygems] fix for gems not downloading from
 git via http

https://github.com/rubygems/rubygems/commit/592a2fcd54
---
 lib/bundler/source/git/git_proxy.rb               |  8 ++++++++
 spec/bundler/bundler/source/git/git_proxy_spec.rb | 14 ++++++++++++++
 2 files changed, 22 insertions(+)

diff --git a/lib/bundler/source/git/git_proxy.rb b/lib/bundler/source/git/git_proxy.rb
index 645851286cda69..f89e465c07dbd5 100644
--- a/lib/bundler/source/git/git_proxy.rb
+++ b/lib/bundler/source/git/git_proxy.rb
@@ -181,6 +181,14 @@ def clone_needs_extra_fetch?
 
             if err.include?("Could not find remote branch")
               raise MissingGitRevisionError.new(command_with_no_credentials, nil, explicit_ref, credential_filtered_uri)
+            elsif err.include?("dumb http transport does not support shallow capabilities")
+              idx = command.index("--depth")
+              if idx
+                command.delete_at(idx)
+                command.delete_at(idx)
+                err += "Retrying without --depth argument."
+              end
+              raise GitCommandError.new(command_with_no_credentials, path, err)
             else
               raise GitCommandError.new(command_with_no_credentials, path, err)
             end
diff --git a/spec/bundler/bundler/source/git/git_proxy_spec.rb b/spec/bundler/bundler/source/git/git_proxy_spec.rb
index 1450316d59bdea..f7c883eed4b5a0 100644
--- a/spec/bundler/bundler/source/git/git_proxy_spec.rb
+++ b/spec/bundler/bundler/source/git/git_proxy_spec.rb
@@ -197,4 +197,18 @@
 
     expect(Pathname.new(bundled_app("canary"))).not_to exist
   end
+
+  context "URI is HTTP" do
+    let(:uri) { "http://github.com/rubygems/rubygems.git" }
+    let(:without_depth_arguments) { ["clone", "--bare", "--no-hardlinks", "--quiet", "--no-tags", "--single-branch"] }
+    let(:fail_clone_result) { double(Process::Status, success?: false) }
+
+    it "retries without --depth when git url is http and fails" do
+      allow(git_proxy).to receive(:git_local).with("--version").and_return("git version 2.14.0")
+      allow(git_proxy).to receive(:capture).with([*base_clone_args, "--", uri, path.to_s], nil).and_return(["", "dumb http transport does not support shallow capabilities", fail_clone_result])
+      expect(git_proxy).to receive(:capture).with([*without_depth_arguments, "--", uri, path.to_s], nil).and_return(["", "", clone_result])
+
+      subject.checkout
+    end
+  end
 end

From 5b9b6b4d2b58dc880ddd0a9d45bddc59aee43deb Mon Sep 17 00:00:00 2001
From: Ellen Keal <ekeal@mpr.org>
Date: Mon, 13 May 2024 16:49:56 -0500
Subject: [PATCH 149/242] [rubygems/rubygems] move git clone depth error
 handling to else branch

https://github.com/rubygems/rubygems/commit/022eb473f8
---
 lib/bundler/source/git/git_proxy.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/bundler/source/git/git_proxy.rb b/lib/bundler/source/git/git_proxy.rb
index f89e465c07dbd5..2fc9c6535f0ff2 100644
--- a/lib/bundler/source/git/git_proxy.rb
+++ b/lib/bundler/source/git/git_proxy.rb
@@ -181,16 +181,16 @@ def clone_needs_extra_fetch?
 
             if err.include?("Could not find remote branch")
               raise MissingGitRevisionError.new(command_with_no_credentials, nil, explicit_ref, credential_filtered_uri)
-            elsif err.include?("dumb http transport does not support shallow capabilities")
+            else
               idx = command.index("--depth")
               if idx
                 command.delete_at(idx)
                 command.delete_at(idx)
+                command_with_no_credentials = check_allowed(command)
+
                 err += "Retrying without --depth argument."
               end
               raise GitCommandError.new(command_with_no_credentials, path, err)
-            else
-              raise GitCommandError.new(command_with_no_credentials, path, err)
             end
           end
         end

From 5613d6e95bc09c2e8d2794590bb18444e0a4051d Mon Sep 17 00:00:00 2001
From: git <svn-admin@ruby-lang.org>
Date: Wed, 22 May 2024 06:59:19 +0000
Subject: [PATCH 150/242] Update bundled gems list as of 2024-05-22

---
 NEWS.md           | 2 +-
 gems/bundled_gems | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 558da7ebb50beb..87b2b143810058 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -58,7 +58,7 @@ The following default gems are updated.
 
 The following bundled gems are updated.
 
-* minitest 5.23.0
+* minitest 5.23.1
 * rake 13.2.1
 * test-unit 3.6.2
 * rexml 3.2.8
diff --git a/gems/bundled_gems b/gems/bundled_gems
index 1ff6fbc314f024..bc141542ddaa07 100644
--- a/gems/bundled_gems
+++ b/gems/bundled_gems
@@ -6,7 +6,7 @@
 # - revision: revision in repository-url to test
 #   if `revision` is not given, "v"+`version` or `version` will be used.
 
-minitest        5.23.0  https://github.com/minitest/minitest
+minitest        5.23.1  https://github.com/minitest/minitest
 power_assert    2.0.3   https://github.com/ruby/power_assert 84e85124c5014a139af39161d484156cfe87a9ed
 rake            13.2.1  https://github.com/ruby/rake
 test-unit       3.6.2   https://github.com/test-unit/test-unit

From e575954887a8e8ae26a4122c33c66b8cb82dfa36 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 22 May 2024 14:31:38 -0400
Subject: [PATCH 151/242] [ruby/prism] Fix support for 'it' implicit local
 variable

https://github.com/ruby/prism/commit/53bbcfe513
---
 lib/prism/translation/parser/compiler.rb |  15 +-
 lib/prism/translation/ripper.rb          |  14 +-
 lib/prism/translation/ruby_parser.rb     |   6 +
 prism/config.yml                         |  10 +-
 prism/parser.h                           |  49 ++-
 prism/prism.c                            | 433 +++++++++++------------
 prism/templates/src/diagnostic.c.erb     |   6 +-
 prism/templates/src/token_type.c.erb     |   2 +-
 test/prism/errors_test.rb                |   8 +-
 test/prism/location_test.rb              |  32 +-
 10 files changed, 292 insertions(+), 283 deletions(-)

diff --git a/lib/prism/translation/parser/compiler.rb b/lib/prism/translation/parser/compiler.rb
index c3fa68231ce8b5..08e54a7bf3d9ec 100644
--- a/lib/prism/translation/parser/compiler.rb
+++ b/lib/prism/translation/parser/compiler.rb
@@ -1148,6 +1148,12 @@ def visit_interpolated_x_string_node(node)
           end
         end
 
+        # -> { it }
+        #      ^^
+        def visit_it_local_variable_read_node(node)
+          builder.ident([:it, srange(node.location)]).updated(:lvar)
+        end
+
         # -> { it }
         # ^^^^^^^^^
         def visit_it_parameters_node(node)
@@ -1201,14 +1207,7 @@ def visit_lambda_node(node)
         # foo
         # ^^^
         def visit_local_variable_read_node(node)
-          name = node.name
-
-          # This is just a guess. parser doesn't have support for the implicit
-          # `it` variable yet, so we'll probably have to visit this once it
-          # does.
-          name = :it if name == :"0it"
-
-          builder.ident([name, srange(node.location)]).updated(:lvar)
+          builder.ident([node.name, srange(node.location)]).updated(:lvar)
         end
 
         # foo = 1
diff --git a/lib/prism/translation/ripper.rb b/lib/prism/translation/ripper.rb
index 68f658565d145d..79ba0e7ab331af 100644
--- a/lib/prism/translation/ripper.rb
+++ b/lib/prism/translation/ripper.rb
@@ -2217,6 +2217,13 @@ def visit_interpolated_x_string_node(node)
         end
       end
 
+      # -> { it }
+      #      ^^
+      def visit_it_local_variable_read_node(node)
+        bounds(node.location)
+        on_vcall(on_ident(node.slice))
+      end
+
       # -> { it }
       # ^^^^^^^^^
       def visit_it_parameters_node(node)
@@ -2312,12 +2319,7 @@ def visit_lambda_node(node)
       # ^^^
       def visit_local_variable_read_node(node)
         bounds(node.location)
-
-        if node.name == :"0it"
-          on_vcall(on_ident(node.slice))
-        else
-          on_var_ref(on_ident(node.slice))
-        end
+        on_var_ref(on_ident(node.slice))
       end
 
       # foo = 1
diff --git a/lib/prism/translation/ruby_parser.rb b/lib/prism/translation/ruby_parser.rb
index 6e745a9041b0aa..fe08a493d6f29d 100644
--- a/lib/prism/translation/ruby_parser.rb
+++ b/lib/prism/translation/ruby_parser.rb
@@ -916,6 +916,12 @@ def visit_interpolated_x_string_node(node)
           end
         end
 
+        # -> { it }
+        #      ^^
+        def visit_it_local_variable_read_node(node)
+          s(node, :call, nil, :it)
+        end
+
         # foo(bar: baz)
         #     ^^^^^^^^
         def visit_keyword_hash_node(node)
diff --git a/prism/config.yml b/prism/config.yml
index 08441ca4decfee..35daacf614ac52 100644
--- a/prism/config.yml
+++ b/prism/config.yml
@@ -2570,6 +2570,12 @@ nodes:
 
           `foo #{bar} baz`
           ^^^^^^^^^^^^^^^^
+  - name: ItLocalVariableReadNode
+    comment: |
+      Represents reading from the implicit `it` local variable.
+
+          -> { it }
+               ^^
   - name: ItParametersNode
     comment: |
       Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
@@ -2695,10 +2701,6 @@ nodes:
 
               _1     # name `:_1`
 
-          Finally, for the default `it` block parameter, the name is `0it`. This is to distinguish it from an `it` local variable that is explicitly declared.
-
-              it     # name `:0it`
-
       - name: depth
         type: uint32
         comment: |
diff --git a/prism/parser.h b/prism/parser.h
index ff1261841cc016..2bae4b0ac331a0 100644
--- a/prism/parser.h
+++ b/prism/parser.h
@@ -546,6 +546,17 @@ typedef struct pm_locals {
     pm_local_t *locals;
 } pm_locals_t;
 
+/** The flags about scope parameters that can be set. */
+typedef uint8_t pm_scope_parameters_t;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NONE = 0x0;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS = 0x1;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS = 0x2;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_BLOCK = 0x4;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_ALL = 0x8;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED = 0x10;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NUMBERED_INNER = 0x20;
+static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NUMBERED_FOUND = 0x40;
+
 /**
  * This struct represents a node in a linked list of scopes. Some scopes can see
  * into their parent scopes, while others cannot.
@@ -557,10 +568,19 @@ typedef struct pm_scope {
     /** The IDs of the locals in the given scope. */
     pm_locals_t locals;
 
+    /**
+     * This is a list of the implicit parameters contained within the block.
+     * These will be processed after the block is parsed to determine the kind
+     * of parameters node that should be used and to check if any errors need to
+     * be added.
+     */
+    pm_node_list_t implicit_parameters;
+
     /**
      * This is a bitfield that indicates the parameters that are being used in
-     * this scope. It is a combination of the PM_SCOPE_PARAMS_* constants. There
-     * are three different kinds of parameters that can be used in a scope:
+     * this scope. It is a combination of the PM_SCOPE_PARAMETERS_* constants.
+     * There are three different kinds of parameters that can be used in a
+     * scope:
      *
      * - Ordinary parameters (e.g., def foo(bar); end)
      * - Numbered parameters (e.g., def foo; _1; end)
@@ -575,15 +595,7 @@ typedef struct pm_scope {
      * - def foo(&); end
      * - def foo(...); end
      */
-    uint8_t parameters;
-
-    /**
-     * An integer indicating the number of numbered parameters on this scope.
-     * This is necessary to determine if child blocks are allowed to use
-     * numbered parameters, and to pass information to consumers of the AST
-     * about how many numbered parameters exist.
-     */
-    int8_t numbered_parameters;
+    pm_scope_parameters_t parameters;
 
     /**
      * The current state of constant shareability for this scope. This is
@@ -598,21 +610,6 @@ typedef struct pm_scope {
     bool closed;
 } pm_scope_t;
 
-static const uint8_t PM_SCOPE_PARAMETERS_NONE = 0x0;
-static const uint8_t PM_SCOPE_PARAMETERS_ORDINARY = 0x1;
-static const uint8_t PM_SCOPE_PARAMETERS_NUMBERED = 0x2;
-static const uint8_t PM_SCOPE_PARAMETERS_IT = 0x4;
-static const uint8_t PM_SCOPE_PARAMETERS_TYPE_MASK = 0x7;
-
-static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS = 0x8;
-static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS = 0x10;
-static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_BLOCK = 0x20;
-static const uint8_t PM_SCOPE_PARAMETERS_FORWARDING_ALL = 0x40;
-
-static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_INNER = -2;
-static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED = -1;
-static const int8_t PM_SCOPE_NUMBERED_PARAMETERS_NONE = 0;
-
 /**
  * A struct that represents a stack of boolean values.
  */
diff --git a/prism/prism.c b/prism/prism.c
index a47aa08ce251ed..71cb4ad698ff52 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -708,7 +708,7 @@ pm_parser_scope_push(pm_parser_t *parser, bool closed) {
         .previous = parser->current_scope,
         .locals = { 0 },
         .parameters = PM_SCOPE_PARAMETERS_NONE,
-        .numbered_parameters = PM_SCOPE_NUMBERED_PARAMETERS_NONE,
+        .implicit_parameters = { 0 },
         .shareable_constant = (closed || parser->current_scope == NULL) ? PM_SCOPE_SHAREABLE_CONSTANT_NONE : parser->current_scope->shareable_constant,
         .closed = closed
     };
@@ -4322,7 +4322,7 @@ pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
     const uint8_t *point = memchr(start, '.', length);
     assert(point && "should have a decimal point");
 
-    uint8_t *digits = malloc(length - 1);
+    uint8_t *digits = malloc(length);
     if (digits == NULL) {
         fputs("[pm_float_node_rational_create] Failed to allocate memory", stderr);
         abort();
@@ -4333,7 +4333,7 @@ pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
     pm_integer_parse(&node->numerator, PM_INTEGER_BASE_DEFAULT, digits, digits + length - 1);
 
     digits[0] = '1';
-    memset(digits + 1, '0', (size_t) (end - point - 1));
+    if (end - point > 1) memset(digits + 1, '0', (size_t) (end - point - 1));
     pm_integer_parse(&node->denominator, PM_INTEGER_BASE_DEFAULT, digits, digits + (end - point));
     free(digits);
 
@@ -5497,6 +5497,23 @@ pm_interpolated_xstring_node_closing_set(pm_interpolated_x_string_node_t *node,
     node->base.location.end = closing->end;
 }
 
+/**
+ * Create a local variable read that is reading the implicit 'it' variable.
+ */
+static pm_it_local_variable_read_node_t *
+pm_it_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
+    pm_it_local_variable_read_node_t *node = PM_ALLOC_NODE(parser, pm_it_local_variable_read_node_t);
+
+    *node = (pm_it_local_variable_read_node_t) {
+        {
+            .type = PM_IT_LOCAL_VARIABLE_READ_NODE,
+            .location = PM_LOCATION_TOKEN_VALUE(name)
+        }
+    };
+
+    return node;
+}
+
 /**
  * Allocate and initialize a new ItParametersNode node.
  */
@@ -5809,28 +5826,6 @@ pm_token_is_it(const uint8_t *start, const uint8_t *end) {
     return (end - start == 2) && (start[0] == 'i') && (start[1] == 't');
 }
 
-/**
- * Returns true if the given node is `it` default parameter.
- */
-static inline bool
-pm_node_is_it(pm_parser_t *parser, pm_node_t *node) {
-    // Check if it's a local variable reference
-    if (node->type != PM_CALL_NODE) {
-        return false;
-    }
-
-    // Check if it's a variable call
-    pm_call_node_t *call_node = (pm_call_node_t *) node;
-    if (!PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
-        return false;
-    }
-
-    // Check if it's called `it`
-    pm_constant_id_t id = ((pm_call_node_t *)node)->name;
-    pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, id);
-    return pm_token_is_it(constant->start, constant->start + constant->length);
-}
-
 /**
  * Returns true if the given bounds comprise a numbered parameter (i.e., they
  * are of the form /^_\d$/).
@@ -7951,51 +7946,6 @@ pm_parser_local_add_constant(pm_parser_t *parser, const char *start, size_t leng
     return constant_id;
 }
 
-/**
- * Create a local variable read that is reading the implicit 'it' variable.
- */
-static pm_local_variable_read_node_t *
-pm_local_variable_read_node_create_it(pm_parser_t *parser, const pm_token_t *name) {
-    if (parser->current_scope->parameters & PM_SCOPE_PARAMETERS_ORDINARY) {
-        pm_parser_err_token(parser, name, PM_ERR_IT_NOT_ALLOWED_ORDINARY);
-        return NULL;
-    }
-
-    if (parser->current_scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED) {
-        pm_parser_err_token(parser, name, PM_ERR_IT_NOT_ALLOWED_NUMBERED);
-        return NULL;
-    }
-
-    parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_IT;
-
-    pm_constant_id_t name_id = pm_parser_constant_id_constant(parser, "0it", 3);
-    pm_parser_local_add(parser, name_id, name->start, name->end, 0);
-
-    return pm_local_variable_read_node_create_constant_id(parser, name, name_id, 0, false);
-}
-
-/**
- * Convert a `it` variable call node to a node for `it` default parameter.
- */
-static pm_node_t *
-pm_node_check_it(pm_parser_t *parser, pm_node_t *node) {
-    if (
-        (parser->version != PM_OPTIONS_VERSION_CRUBY_3_3) &&
-        !parser->current_scope->closed &&
-        (parser->current_scope->numbered_parameters != PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED) &&
-        pm_node_is_it(parser, node)
-    ) {
-        pm_local_variable_read_node_t *read = pm_local_variable_read_node_create_it(parser, &parser->previous);
-
-        if (read != NULL) {
-            pm_node_destroy(parser, node);
-            node = (pm_node_t *) read;
-        }
-    }
-
-    return node;
-}
-
 /**
  * Add a parameter name to the current scope and check whether the name of the
  * parameter is unique or not.
@@ -8031,6 +7981,7 @@ pm_parser_scope_pop(pm_parser_t *parser) {
     pm_scope_t *scope = parser->current_scope;
     parser->current_scope = scope->previous;
     pm_locals_free(&scope->locals);
+    pm_node_list_free(&scope->implicit_parameters);
     xfree(scope);
 }
 
@@ -13187,6 +13138,30 @@ parse_unwriteable_target(pm_parser_t *parser, pm_node_t *target) {
     return (pm_node_t *) result;
 }
 
+/**
+ * When an implicit local variable is written to or targeted, it becomes a
+ * regular, named local variable. This function removes it from the list of
+ * implicit parameters when that happens.
+ */
+static void
+parse_target_implicit_parameter(pm_parser_t *parser, pm_node_t *node) {
+    pm_node_list_t *implicit_parameters = &parser->current_scope->implicit_parameters;
+
+    for (size_t index = 0; index < implicit_parameters->size; index++) {
+        if (implicit_parameters->nodes[index] == node) {
+            // If the node is not the last one in the list, we need to shift the
+            // remaining nodes down to fill the gap. This is extremely unlikely
+            // to happen.
+            if (index != implicit_parameters->size - 1) {
+                memcpy(&implicit_parameters->nodes[index], &implicit_parameters->nodes[index + 1], (implicit_parameters->size - index - 1) * sizeof(pm_node_t *));
+            }
+
+            implicit_parameters->size--;
+            break;
+        }
+    }
+}
+
 /**
  * Convert the given node into a valid target node.
  */
@@ -13237,7 +13212,10 @@ parse_target(pm_parser_t *parser, pm_node_t *target, bool multiple) {
             target->type = PM_GLOBAL_VARIABLE_TARGET_NODE;
             return target;
         case PM_LOCAL_VARIABLE_READ_NODE: {
-            pm_refute_numbered_parameter(parser, target->location.start, target->location.end);
+            if (pm_token_is_numbered_parameter(target->location.start, target->location.end)) {
+                PM_PARSER_ERR_FORMAT(parser, target->location.start, target->location.end, PM_ERR_PARAMETER_NUMBERED_RESERVED, target->location.start);
+                parse_target_implicit_parameter(parser, target);
+            }
 
             const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) target;
             uint32_t name = cast->name;
@@ -13249,6 +13227,15 @@ parse_target(pm_parser_t *parser, pm_node_t *target, bool multiple) {
 
             return target;
         }
+        case PM_IT_LOCAL_VARIABLE_READ_NODE: {
+            pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
+            pm_node_t *node = (pm_node_t *) pm_local_variable_target_node_create(parser, &target->location, name, 0);
+
+            parse_target_implicit_parameter(parser, target);
+            pm_node_destroy(parser, target);
+
+            return node;
+        }
         case PM_INSTANCE_VARIABLE_READ_NODE:
             assert(sizeof(pm_instance_variable_target_node_t) == sizeof(pm_instance_variable_read_node_t));
             target->type = PM_INSTANCE_VARIABLE_TARGET_NODE;
@@ -13410,8 +13397,9 @@ parse_write(pm_parser_t *parser, pm_node_t *target, pm_token_t *operator, pm_nod
             pm_scope_t *scope = pm_parser_scope_find(parser, depth);
 
             if (pm_token_is_numbered_parameter(target->location.start, target->location.end)) {
-                pm_diagnostic_id_t diag_id = scope->parameters > PM_SCOPE_NUMBERED_PARAMETERS_NONE ? PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED : PM_ERR_PARAMETER_NUMBERED_RESERVED;
+                pm_diagnostic_id_t diag_id = (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND) ? PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED : PM_ERR_PARAMETER_NUMBERED_RESERVED;
                 PM_PARSER_ERR_FORMAT(parser, target->location.start, target->location.end, diag_id, target->location.start);
+                parse_target_implicit_parameter(parser, target);
             }
 
             pm_locals_unread(&scope->locals, name);
@@ -13419,6 +13407,15 @@ parse_write(pm_parser_t *parser, pm_node_t *target, pm_token_t *operator, pm_nod
 
             return (pm_node_t *) pm_local_variable_write_node_create(parser, name, depth, value, &name_loc, operator);
         }
+        case PM_IT_LOCAL_VARIABLE_READ_NODE: {
+            pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
+            pm_node_t *node = (pm_node_t *) pm_local_variable_write_node_create(parser, name, 0, value, &target->location, operator);
+
+            parse_target_implicit_parameter(parser, target);
+            pm_node_destroy(parser, target);
+
+            return node;
+        }
         case PM_INSTANCE_VARIABLE_READ_NODE: {
             pm_node_t *write_node = (pm_node_t *) pm_instance_variable_write_node_create(parser, (pm_instance_variable_read_node_t *) target, operator, value);
             pm_node_destroy(parser, target);
@@ -14860,6 +14857,28 @@ parse_block_parameters(
     return block_parameters;
 }
 
+/**
+ * Return true if any of the visible scopes to the current context are using
+ * numbered parameters.
+ */
+static bool
+outer_scope_using_numbered_parameters_p(pm_parser_t *parser) {
+    for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
+        if (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND) return true;
+    }
+
+    return false;
+}
+
+/**
+ * These are the names of the various numbered parameters. We have them here so
+ * that when we insert them into the constant pool we can use a constant string
+ * and not have to allocate.
+ */
+static const char * const pm_numbered_parameter_names[] = {
+    "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"
+};
+
 /**
  * Return the node that should be used in the parameters field of a block-like
  * (block or lambda) node, depending on the kind of parameters that were
@@ -14867,31 +14886,79 @@ parse_block_parameters(
  */
 static pm_node_t *
 parse_blocklike_parameters(pm_parser_t *parser, pm_node_t *parameters, const pm_token_t *opening, const pm_token_t *closing) {
-    uint8_t masked = parser->current_scope->parameters & PM_SCOPE_PARAMETERS_TYPE_MASK;
+    pm_node_list_t *implicit_parameters = &parser->current_scope->implicit_parameters;
+
+    // If we have ordinary parameters, then we will return them as the set of
+    // parameters.
+    if (parameters != NULL) {
+        // If we also have implicit parameters, then this is an error.
+        if (implicit_parameters->size > 0) {
+            pm_node_t *node = implicit_parameters->nodes[0];
+
+            if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
+                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_ORDINARY);
+            } else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
+                pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_ORDINARY);
+            } else {
+                assert(false && "unreachable");
+            }
+        }
 
-    if (masked == PM_SCOPE_PARAMETERS_NONE) {
-        assert(parameters == NULL);
-        return NULL;
-    } else if (masked == PM_SCOPE_PARAMETERS_ORDINARY) {
-        assert(parameters != NULL);
         return parameters;
-    } else if (masked == PM_SCOPE_PARAMETERS_NUMBERED) {
-        assert(parameters == NULL);
+    }
 
-        int8_t maximum = parser->current_scope->numbered_parameters;
-        if (maximum > 0) {
-            const pm_location_t location = { .start = opening->start, .end = closing->end };
-            return (pm_node_t *) pm_numbered_parameters_node_create(parser, &location, (uint8_t) maximum);
+    // If we don't have any implicit parameters, then the set of parameters is
+    // NULL.
+    if (implicit_parameters->size == 0) {
+        return NULL;
+    }
+
+    // If we don't have ordinary parameters, then we now must validate our set
+    // of implicit parameters. We can only have numbered parameters or it, but
+    // they cannot be mixed.
+    uint8_t numbered_parameter = 0;
+    bool it_parameter = false;
+
+    for (size_t index = 0; index < implicit_parameters->size; index++) {
+        pm_node_t *node = implicit_parameters->nodes[index];
+
+        if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
+            if (it_parameter) {
+                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_IT);
+            } else if (outer_scope_using_numbered_parameters_p(parser)) {
+                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK);
+            } else if (parser->current_scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_INNER) {
+                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK);
+            } else if (pm_token_is_numbered_parameter(node->location.start, node->location.end)) {
+                numbered_parameter = MAX(numbered_parameter, (uint8_t) (node->location.start[1] - '0'));
+            } else {
+                assert(false && "unreachable");
+            }
+        } else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
+            if (numbered_parameter > 0) {
+                pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_NUMBERED);
+            } else {
+                it_parameter = true;
+            }
         }
+    }
 
-        return NULL;
-    } else if (masked == PM_SCOPE_PARAMETERS_IT) {
-        assert(parameters == NULL);
+    if (numbered_parameter > 0) {
+        // Go through the parent scopes and mark them as being disallowed from
+        // using numbered parameters because this inner scope is using them.
+        for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
+            scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_INNER;
+        }
+
+        const pm_location_t location = { .start = opening->start, .end = closing->end };
+        return (pm_node_t *) pm_numbered_parameters_node_create(parser, &location, numbered_parameter);
+    }
+
+    if (it_parameter) {
         return (pm_node_t *) pm_it_parameters_node_create(parser, opening, closing);
-    } else {
-        assert(false && "unreachable");
-        return NULL;
     }
+
+    return NULL;
 }
 
 /**
@@ -14908,9 +14975,6 @@ parse_block(pm_parser_t *parser) {
     pm_block_parameters_node_t *block_parameters = NULL;
 
     if (accept1(parser, PM_TOKEN_PIPE)) {
-        assert(parser->current_scope->parameters == PM_SCOPE_PARAMETERS_NONE);
-        parser->current_scope->parameters = PM_SCOPE_PARAMETERS_ORDINARY;
-
         pm_token_t block_parameters_opening = parser->previous;
         if (match1(parser, PM_TOKEN_PIPE)) {
             block_parameters = pm_block_parameters_node_create(parser, NULL, &block_parameters_opening);
@@ -15408,7 +15472,7 @@ parse_conditional(pm_parser_t *parser, pm_context_t context) {
 #define PM_CASE_WRITABLE PM_CLASS_VARIABLE_READ_NODE: case PM_CONSTANT_PATH_NODE: \
     case PM_CONSTANT_READ_NODE: case PM_GLOBAL_VARIABLE_READ_NODE: case PM_LOCAL_VARIABLE_READ_NODE: \
     case PM_INSTANCE_VARIABLE_READ_NODE: case PM_MULTI_TARGET_NODE: case PM_BACK_REFERENCE_READ_NODE: \
-    case PM_NUMBERED_REFERENCE_READ_NODE
+    case PM_NUMBERED_REFERENCE_READ_NODE: case PM_IT_LOCAL_VARIABLE_READ_NODE
 
 // Assert here that the flags are the same so that we can safely switch the type
 // of the node without having to move the flags.
@@ -15827,92 +15891,44 @@ parse_alias_argument(pm_parser_t *parser, bool first) {
     }
 }
 
-/**
- * Return true if any of the visible scopes to the current context are using
- * numbered parameters.
- */
-static bool
-outer_scope_using_numbered_parameters_p(pm_parser_t *parser) {
-    for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
-        if (scope->numbered_parameters > 0) return true;
-    }
-
-    return false;
-}
-
-/**
- * These are the names of the various numbered parameters. We have them here so
- * that when we insert them into the constant pool we can use a constant string
- * and not have to allocate.
- */
-static const char * const pm_numbered_parameter_names[] = {
-    "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"
-};
-
 /**
  * Parse an identifier into either a local variable read. If the local variable
  * is not found, it returns NULL instead.
  */
-static pm_local_variable_read_node_t *
+static pm_node_t *
 parse_variable(pm_parser_t *parser) {
+    pm_constant_id_t name_id = pm_parser_constant_id_token(parser, &parser->previous);
     int depth;
-    if ((depth = pm_parser_local_depth(parser, &parser->previous)) != -1) {
-        return pm_local_variable_read_node_create(parser, &parser->previous, (uint32_t) depth);
+
+    if ((depth = pm_parser_local_depth_constant_id(parser, name_id)) != -1) {
+        return (pm_node_t *) pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, (uint32_t) depth, false);
     }
 
     pm_scope_t *current_scope = parser->current_scope;
-    if (!current_scope->closed && current_scope->numbered_parameters != PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED && pm_token_is_numbered_parameter(parser->previous.start, parser->previous.end)) {
-        // Now that we know we have a numbered parameter, we need to check
-        // if it's allowed in this context. If it is, then we will create a
-        // local variable read. If it's not, then we'll create a normal call
-        // node but add an error.
-        if (current_scope->parameters & PM_SCOPE_PARAMETERS_ORDINARY) {
-            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_ORDINARY);
-        } else if (current_scope->parameters & PM_SCOPE_PARAMETERS_IT) {
-            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_IT);
-        } else if (outer_scope_using_numbered_parameters_p(parser)) {
-            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK);
-        } else if (current_scope->numbered_parameters == PM_SCOPE_NUMBERED_PARAMETERS_INNER) {
-            pm_parser_err_previous(parser, PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK);
-        } else {
-            // Indicate that this scope is using numbered params so that child
-            // scopes cannot. We subtract the value for the character '0' to get
-            // the actual integer value of the number (only _1 through _9 are
-            // valid).
-            int8_t numbered_parameters = (int8_t) (parser->previous.start[1] - '0');
-
-            // If we're about to match an =, then this is an invalid use of
-            // numbered parameters. We'll create all of the necessary
-            // infrastructure around it, but not actually mark the scope as
-            // using numbered parameters so that we can get the right error
-            // message.
-            if (!match1(parser, PM_TOKEN_EQUAL)) {
-                current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED;
-
-                if (numbered_parameters > current_scope->numbered_parameters) {
-                    current_scope->numbered_parameters = numbered_parameters;
-                }
-
-                // Go through the parent scopes and mark them as being
-                // disallowed from using numbered parameters because this inner
-                // scope is using them.
-                for (pm_scope_t *scope = current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
-                    scope->numbered_parameters = PM_SCOPE_NUMBERED_PARAMETERS_INNER;
-                }
+    if (!current_scope->closed && !(current_scope->parameters & PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED)) {
+        if (pm_token_is_numbered_parameter(parser->previous.start, parser->previous.end)) {
+            // When you use a numbered parameter, it implies the existence of
+            // all of the locals that exist before it. For example, referencing
+            // _2 means that _1 must exist. Therefore here we loop through all
+            // of the possibilities and add them into the constant pool.
+            uint8_t maximum = (uint8_t) (parser->previous.start[1] - '0');
+            for (uint8_t number = 1; number <= maximum; number++) {
+                pm_parser_local_add_constant(parser, pm_numbered_parameter_names[number - 1], 2);
             }
 
-            // When you use a numbered parameter, it implies the existence
-            // of all of the locals that exist before it. For example,
-            // referencing _2 means that _1 must exist. Therefore here we
-            // loop through all of the possibilities and add them into the
-            // constant pool.
-            for (int8_t numbered_param = 1; numbered_param <= numbered_parameters - 1; numbered_param++) {
-                pm_parser_local_add_constant(parser, pm_numbered_parameter_names[numbered_param - 1], 2);
+            if (!match1(parser, PM_TOKEN_EQUAL)) {
+                parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_FOUND;
             }
 
-            // Finally we can create the local variable read node.
-            pm_constant_id_t name_id = pm_parser_local_add_constant(parser, pm_numbered_parameter_names[numbered_parameters - 1], 2);
-            return pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, 0, false);
+            pm_node_t *node = (pm_node_t *) pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, 0, false);
+            pm_node_list_append(&current_scope->implicit_parameters, node);
+
+            return node;
+        } else if ((parser->version != PM_OPTIONS_VERSION_CRUBY_3_3) && pm_token_is_it(parser->previous.start, parser->previous.end)) {
+            pm_node_t *node = (pm_node_t *) pm_it_local_variable_read_node_create(parser, &parser->previous);
+            pm_node_list_append(&current_scope->implicit_parameters, node);
+
+            return node;
         }
     }
 
@@ -15927,8 +15943,8 @@ parse_variable_call(pm_parser_t *parser) {
     pm_node_flags_t flags = 0;
 
     if (!match1(parser, PM_TOKEN_PARENTHESIS_LEFT) && (parser->previous.end[-1] != '!') && (parser->previous.end[-1] != '?')) {
-        pm_local_variable_read_node_t *node = parse_variable(parser);
-        if (node != NULL) return (pm_node_t *) node;
+        pm_node_t *node = parse_variable(parser);
+        if (node != NULL) return node;
         flags |= PM_CALL_NODE_FLAGS_VARIABLE_CALL;
     }
 
@@ -16616,19 +16632,8 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
                     pm_node_t *variable = (pm_node_t *) parse_variable(parser);
 
                     if (variable == NULL) {
-                        if (
-                            (parser->version != PM_OPTIONS_VERSION_CRUBY_3_3) &&
-                            !parser->current_scope->closed &&
-                            (parser->current_scope->numbered_parameters != PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED) &&
-                            pm_token_is_it(parser->previous.start, parser->previous.end)
-                        ) {
-                            pm_local_variable_read_node_t *read = pm_local_variable_read_node_create_it(parser, &parser->previous);
-                            if (read == NULL) read = pm_local_variable_read_node_create(parser, &parser->previous, 0);
-                            variable = (pm_node_t *) read;
-                        } else {
-                            PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, parser->previous, PM_ERR_NO_LOCAL_VARIABLE);
-                            variable = (pm_node_t *) pm_local_variable_read_node_missing_create(parser, &parser->previous, 0);
-                        }
+                        PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, parser->previous, PM_ERR_NO_LOCAL_VARIABLE);
+                        variable = (pm_node_t *) pm_local_variable_read_node_missing_create(parser, &parser->previous, 0);
                     }
 
                     return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
@@ -17378,8 +17383,13 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     break;
                 }
 
-                if (pm_array_node_size(array) != 0) {
-                    expect1(parser, PM_TOKEN_COMMA, PM_ERR_ARRAY_SEPARATOR);
+                // Ensure that we have a comma between elements in the array.
+                if ((pm_array_node_size(array) != 0) && !accept1(parser, PM_TOKEN_COMMA)) {
+                    const uint8_t *location = parser->previous.end;
+                    PM_PARSER_ERR_FORMAT(parser, location, location, PM_ERR_ARRAY_SEPARATOR, pm_token_type_human(parser->current.type));
+
+                    parser->previous.start = location;
+                    parser->previous.type = PM_TOKEN_MISSING;
                 }
 
                 // If we have a right bracket immediately following a comma,
@@ -17807,8 +17817,28 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 ) {
                     pm_arguments_t arguments = { 0 };
                     parse_arguments_list(parser, &arguments, true, accepts_command_call);
-
                     pm_call_node_t *fcall = pm_call_node_fcall_create(parser, &identifier, &arguments);
+
+                    if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
+                        // If we're about to convert an 'it' implicit local
+                        // variable read into a method call, we need to remove
+                        // it from the list of implicit local variables.
+                        parse_target_implicit_parameter(parser, node);
+                    } else {
+                        // Otherwise, we're about to convert a regular local
+                        // variable read into a method call, in which case we
+                        // need to indicate that this was not a read for the
+                        // purposes of warnings.
+                        assert(PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE));
+
+                        if (pm_token_is_numbered_parameter(identifier.start, identifier.end)) {
+                            parse_target_implicit_parameter(parser, node);
+                        } else {
+                            pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
+                            pm_locals_unread(&pm_parser_scope_find(parser, cast->depth)->locals, cast->name);
+                        }
+                    }
+
                     pm_node_destroy(parser, node);
                     return (pm_node_t *) fcall;
                 }
@@ -17816,31 +17846,6 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
             if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
                 node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX);
-            } else {
-                // Check if `it` is not going to be assigned.
-                switch (parser->current.type) {
-                    case PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL:
-                    case PM_TOKEN_AMPERSAND_EQUAL:
-                    case PM_TOKEN_CARET_EQUAL:
-                    case PM_TOKEN_EQUAL:
-                    case PM_TOKEN_GREATER_GREATER_EQUAL:
-                    case PM_TOKEN_LESS_LESS_EQUAL:
-                    case PM_TOKEN_MINUS_EQUAL:
-                    case PM_TOKEN_PARENTHESIS_RIGHT:
-                    case PM_TOKEN_PERCENT_EQUAL:
-                    case PM_TOKEN_PIPE_EQUAL:
-                    case PM_TOKEN_PIPE_PIPE_EQUAL:
-                    case PM_TOKEN_PLUS_EQUAL:
-                    case PM_TOKEN_SLASH_EQUAL:
-                    case PM_TOKEN_STAR_EQUAL:
-                    case PM_TOKEN_STAR_STAR_EQUAL:
-                        break;
-                    default:
-                        // Once we know it's neither a method call nor an
-                        // assignment, we can finally create `it` default
-                        // parameter.
-                        node = pm_node_check_it(parser, node);
-                }
             }
 
             return node;
@@ -19702,9 +19707,6 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
             switch (parser->current.type) {
                 case PM_TOKEN_PARENTHESIS_LEFT: {
-                    assert(parser->current_scope->parameters == PM_SCOPE_PARAMETERS_NONE);
-                    parser->current_scope->parameters = PM_SCOPE_PARAMETERS_ORDINARY;
-
                     pm_token_t opening = parser->current;
                     parser_lex(parser);
 
@@ -19721,9 +19723,6 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     break;
                 }
                 case PM_CASE_PARAMETER: {
-                    assert(parser->current_scope->parameters == PM_SCOPE_PARAMETERS_NONE);
-                    parser->current_scope->parameters = PM_SCOPE_PARAMETERS_ORDINARY;
-
                     pm_accepts_block_stack_push(parser, false);
                     pm_token_t opening = not_provided(parser);
                     block_parameters = parse_block_parameters(parser, false, &opening, true);
@@ -21258,7 +21257,7 @@ pm_parser_init(pm_parser_t *parser, const uint8_t *source, size_t size, const pm
 
             // Scopes given from the outside are not allowed to have numbered
             // parameters.
-            parser->current_scope->numbered_parameters = PM_SCOPE_NUMBERED_PARAMETERS_DISALLOWED;
+            parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED;
 
             for (size_t local_index = 0; local_index < scope->locals_count; local_index++) {
                 const pm_string_t *local = pm_options_scope_local_get(scope, local_index);
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 30d6b0ffedc4be..715cbd659813fe 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -112,7 +112,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_ARRAY_ELEMENT]                      = { "expected an element for the array", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION]                   = { "expected an expression for the array element", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION_AFTER_STAR]        = { "expected an expression after `*` in the array", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ARRAY_SEPARATOR]                    = { "expected a `,` separator for the array elements", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARRAY_SEPARATOR]                    = { "unexpected %s; expected a `,` separator for the array elements", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_TERM]                         = { "expected a `]` to close the array", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_BEGIN_LONELY_ELSE]                  = { "unexpected `else` in `begin` block; else without rescue is useless", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_BEGIN_TERM]                         = { "expected an `end` to close the `begin` statement", PM_ERROR_LEVEL_SYNTAX },
@@ -245,7 +245,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3]        = { "`%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_VARIABLE_GLOBAL]            = { "'%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_YIELD]                      = { "Invalid yield", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "`it` is not allowed when an numbered parameter is defined", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "`it` is not allowed when a numbered parameter is already used", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_IT_NOT_ALLOWED_ORDINARY]            = { "`it` is not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LAMBDA_OPEN]                        = { "expected a `do` keyword or a `{` to open the lambda block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_LAMBDA_TERM_BRACE]                  = { "expected a lambda block beginning with `{` to end with `}`", PM_ERROR_LEVEL_SYNTAX },
@@ -269,7 +269,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_NO_LOCAL_VARIABLE]                  = { "%.*s: no such local variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBER_LITERAL_UNDERSCORE]          = { "number literal ending with a `_`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK]     = { "numbered parameter is already used in inner block", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when an 'it' parameter is defined", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when 'it' is already used", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_ORDINARY]        = { "numbered parameters are not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK]     = { "numbered parameter is already used in outer block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_OPERATOR_MULTI_ASSIGN]              = { "unexpected operator for a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
diff --git a/prism/templates/src/token_type.c.erb b/prism/templates/src/token_type.c.erb
index af6a2ad6fe2a86..f196393ee12661 100644
--- a/prism/templates/src/token_type.c.erb
+++ b/prism/templates/src/token_type.c.erb
@@ -352,7 +352,7 @@ pm_token_type_human(pm_token_type_t token_type) {
         case PM_TOKEN_USTAR:
             return "*";
         case PM_TOKEN_USTAR_STAR:
-            return "'**'";
+            return "**";
         case PM_TOKEN_WORDS_SEP:
             return "string separator";
         case PM_TOKEN___END__:
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 6f926452fa8809..50417e476e7dc7 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -1356,14 +1356,14 @@ def test_index_call_with_block_operator_write
 
     if RUBY_VERSION >= "3.0"
       def test_writing_numbered_parameter
-        assert_errors expression("-> { _1 = 0 }"), "-> { _1 = 0 }", [
-          ["_1 is reserved for numbered parameters", 5..7]
+        assert_error_messages "-> { _1 = 0 }", [
+          "_1 is reserved for numbered parameters"
         ]
       end
 
       def test_targeting_numbered_parameter
-        assert_errors expression("-> { _1, = 0 }"), "-> { _1, = 0 }", [
-          ["_1 is reserved for numbered parameters", 5..7]
+        assert_error_messages "-> { _1, = 0 }", [
+          "_1 is reserved for numbered parameters"
         ]
       end
 
diff --git a/test/prism/location_test.rb b/test/prism/location_test.rb
index 07249956715e91..256e5b41e446ac 100644
--- a/test/prism/location_test.rb
+++ b/test/prism/location_test.rb
@@ -175,14 +175,6 @@ def test_CallNode
 
       assert_location(CallNode, "foo bar baz")
       assert_location(CallNode, "foo bar('baz')")
-
-      assert_location(CallNode, "-> { it }", 5...7, version: "3.3.0") do |node|
-        node.body.body.first
-      end
-
-      assert_location(LocalVariableReadNode, "-> { it }", 5...7, version: "3.4.0") do |node|
-        node.body.body.first
-      end
     end
 
     def test_CallAndWriteNode
@@ -543,6 +535,24 @@ def test_InterpolatedXStringNode
       assert_location(InterpolatedXStringNode, '`foo #{bar} baz`')
     end
 
+    def test_ItLocalVariableReadNode
+      assert_location(ItLocalVariableReadNode, "-> { it }", 5...7) do |node|
+        node.body.body.first
+      end
+
+      assert_location(ItLocalVariableReadNode, "foo { it }", 6...8) do |node|
+        node.block.body.body.first
+      end
+
+      assert_location(CallNode, "-> { it }", 5...7, version: "3.3.0") do |node|
+        node.body.body.first
+      end
+
+      assert_location(ItLocalVariableReadNode, "-> { it }", 5...7, version: "3.4.0") do |node|
+        node.body.body.first
+      end
+    end
+
     def test_ItParametersNode
       assert_location(ItParametersNode, "-> { it }", &:parameters)
     end
@@ -583,12 +593,6 @@ def test_LocalVariableOrWriteNode
 
     def test_LocalVariableReadNode
       assert_location(LocalVariableReadNode, "foo = 1; foo", 9...12)
-      assert_location(LocalVariableReadNode, "-> { it }", 5...7) do |node|
-        node.body.body.first
-      end
-      assert_location(LocalVariableReadNode, "foo { it }", 6...8) do |node|
-        node.block.body.body.first
-      end
     end
 
     def test_LocalVariableTargetNode

From 6d81ae3f013c83bf05371c923898ec4f777cfdba Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 22 May 2024 14:16:36 -0400
Subject: [PATCH 152/242] [PRISM] Properly support 'it'

---
 prism/prism.c                      |  1 -
 prism_compile.c                    | 35 ++++++++++++++++++------------
 test/.excludes-prism/TestSyntax.rb |  1 -
 test/ruby/test_syntax.rb           |  2 +-
 4 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 71cb4ad698ff52..5b27333f221188 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -18511,7 +18511,6 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
                     if (match2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON)) {
                         receiver = parse_variable_call(parser);
-                        receiver = pm_node_check_it(parser, receiver);
 
                         pm_parser_scope_push(parser, true);
                         lex_state_set(parser, PM_LEX_STATE_FNAME);
diff --git a/prism_compile.c b/prism_compile.c
index b6e43d37f68831..5edc1ba2e7f49f 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -6915,6 +6915,15 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
 
         return;
       }
+      case PM_IT_LOCAL_VARIABLE_READ_NODE: {
+        // -> { it }
+        //      ^^
+        if (!popped) {
+            PUSH_GETLOCAL(ret, location, scope_node->local_table_for_iseq_size, 0);
+        }
+
+        return;
+      }
       case PM_KEYWORD_HASH_NODE: {
         // foo(bar: baz)
         //     ^^^^^^^^
@@ -7018,9 +7027,8 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
       case PM_LOCAL_VARIABLE_READ_NODE: {
         // foo
         // ^^^
-        const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
-
         if (!popped) {
+            const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
             pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
             PUSH_GETLOCAL(ret, location, index.index, index.level);
         }
@@ -7962,6 +7970,12 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             }
         }
 
+        // If we have the `it` implicit local variable, we need to account for
+        // it in the local table size.
+        if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
+            table_size++;
+        }
+
         // Ensure there is enough room in the local table for any
         // parameters that have been repeated
         // ex: def underscore_parameters(_, _ = 1, _ = 2); _; end
@@ -8110,6 +8124,11 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             body->param.flags.has_lead = true;
         }
 
+        if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
+            ID local = rb_make_temporary_id(local_index);
+            local_table_for_iseq->ids[local_index++] = local;
+        }
+
         // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
         //                        ^^^^^
         if (optionals_list && optionals_list->size) {
@@ -8470,18 +8489,6 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             body->param.flags.has_lead = true;
         }
 
-        // Fill in the it variable, if it exists
-        if (scope_node->parameters && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
-            const uint8_t param_name[] = { '0', 'i', 't' };
-            pm_constant_id_t constant_id = pm_constant_pool_find(&parser->constant_pool, param_name, 3);
-            RUBY_ASSERT(constant_id && "parser should have inserted 0it for 'it' local");
-
-            ID local = rb_make_temporary_id(local_index);
-            local_table_for_iseq->ids[local_index] = local;
-            st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
-            local_index++;
-        }
-
         //********END OF STEP 3**********
 
         //********STEP 4**********
diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index 4809924acc8a27..b07e2e1e0f4dfe 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,5 +1,4 @@
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
-exclude(:test_it, "https://github.com/ruby/prism/issues/2323")
 exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
 
 exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index 2f311c859ee862..f4c9f064598f8f 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -1922,7 +1922,7 @@ def test_it
       ]
     end
     assert_valid_syntax('proc {def foo(_);end;it}')
-    assert_syntax_error('p { [it **2] }', /unexpected \*\*arg/)
+    assert_syntax_error('p { [it **2] }', /unexpected \*\*/)
   end
 
   def test_value_expr_in_condition

From 2cc047df9a92e0c6b9d0fb57f305f49c4b5ed4cf Mon Sep 17 00:00:00 2001
From: Hiroshi SHIBATA <hsbt@ruby-lang.org>
Date: Thu, 23 May 2024 10:15:49 +0900
Subject: [PATCH 153/242] [ruby/rdoc] Bump up 6.7.0

https://github.com/ruby/rdoc/commit/a667e616e1
---
 lib/rdoc/version.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rdoc/version.rb b/lib/rdoc/version.rb
index 87842d9847a9ee..427d4ae232dd58 100644
--- a/lib/rdoc/version.rb
+++ b/lib/rdoc/version.rb
@@ -5,6 +5,6 @@ module RDoc
   ##
   # RDoc version you are using
 
-  VERSION = '6.6.3.1'
+  VERSION = '6.7.0'
 
 end

From aad09104b75b12bf10527794480ca3bf25809075 Mon Sep 17 00:00:00 2001
From: git <svn-admin@ruby-lang.org>
Date: Thu, 23 May 2024 01:18:20 +0000
Subject: [PATCH 154/242] Update default gems list at
 2cc047df9a92e0c6b9d0fb57f305f4 [ci skip]

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 87b2b143810058..c055d14f8d124f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -50,7 +50,7 @@ The following default gems are updated.
 * net-http 0.4.1
 * optparse 0.5.0
 * prism 0.29.0
-* rdoc 6.6.3.1
+* rdoc 6.7.0
 * reline 0.5.7
 * resolv 0.4.0
 * stringio 3.1.1

From fc9acbaac261af900f898497fda67d510c91efb4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 23 May 2024 03:01:03 +0000
Subject: [PATCH 155/242] Bump ruby/setup-ruby from 1.177.0 to 1.177.1

Bumps [ruby/setup-ruby](https://github.com/ruby/setup-ruby) from 1.177.0 to 1.177.1.
- [Release notes](https://github.com/ruby/setup-ruby/releases)
- [Commits](https://github.com/ruby/setup-ruby/compare/7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c...943103cae7d3f1bb1e4951d5fcc7928b40e4b742)

---
updated-dependencies:
- dependency-name: ruby/setup-ruby
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/annocheck.yml          | 2 +-
 .github/workflows/baseruby.yml           | 2 +-
 .github/workflows/check_dependencies.yml | 2 +-
 .github/workflows/mingw.yml              | 2 +-
 .github/workflows/rjit-bindgen.yml       | 2 +-
 .github/workflows/spec_guards.yml        | 2 +-
 .github/workflows/ubuntu.yml             | 2 +-
 .github/workflows/wasm.yml               | 2 +-
 .github/workflows/windows.yml            | 2 +-
 .github/workflows/yjit-ubuntu.yml        | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/annocheck.yml b/.github/workflows/annocheck.yml
index 252c587580e6e2..fe34ab0222fc6a 100644
--- a/.github/workflows/annocheck.yml
+++ b/.github/workflows/annocheck.yml
@@ -74,7 +74,7 @@ jobs:
           builddir: build
           makeup: true
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/baseruby.yml b/.github/workflows/baseruby.yml
index 4cec3955a3ebcb..09e28cb5f146a0 100644
--- a/.github/workflows/baseruby.yml
+++ b/.github/workflows/baseruby.yml
@@ -51,7 +51,7 @@ jobs:
           - ruby-3.3
 
     steps:
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler: none
diff --git a/.github/workflows/check_dependencies.yml b/.github/workflows/check_dependencies.yml
index 5988947c489693..c52e30a5c67a6c 100644
--- a/.github/workflows/check_dependencies.yml
+++ b/.github/workflows/check_dependencies.yml
@@ -55,7 +55,7 @@ jobs:
 
       - uses: ./.github/actions/setup/directories
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/mingw.yml b/.github/workflows/mingw.yml
index 90ef5281a3cea0..9328b72608c2d2 100644
--- a/.github/workflows/mingw.yml
+++ b/.github/workflows/mingw.yml
@@ -66,7 +66,7 @@ jobs:
 
     steps:
       - name: Set up Ruby & MSYS2
-        uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+        uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: ${{ matrix.baseruby }}
 
diff --git a/.github/workflows/rjit-bindgen.yml b/.github/workflows/rjit-bindgen.yml
index 5b4eee43a1a1f8..531d1e95a8f604 100644
--- a/.github/workflows/rjit-bindgen.yml
+++ b/.github/workflows/rjit-bindgen.yml
@@ -47,7 +47,7 @@ jobs:
 
     steps:
       - name: Set up Ruby
-        uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+        uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.1'
 
diff --git a/.github/workflows/spec_guards.yml b/.github/workflows/spec_guards.yml
index a084b570ebb73a..55e7348bc5be79 100644
--- a/.github/workflows/spec_guards.yml
+++ b/.github/workflows/spec_guards.yml
@@ -47,7 +47,7 @@ jobs:
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler: none
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index f11a96e5d35952..7fbf0504ccb5ac 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -67,7 +67,7 @@ jobs:
         with:
           arch: ${{ matrix.arch }}
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/wasm.yml b/.github/workflows/wasm.yml
index d5f76b0e7ce005..617ce41b37ba4f 100644
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -100,7 +100,7 @@ jobs:
         run: |
           echo "WASI_SDK_PATH=/opt/wasi-sdk" >> $GITHUB_ENV
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index 38504f78d6a6d2..49313bc118a45e 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -91,7 +91,7 @@ jobs:
             ${{ steps.find-tools.outputs.needs }}
         if: ${{ steps.find-tools.outputs.needs != '' }}
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none
diff --git a/.github/workflows/yjit-ubuntu.yml b/.github/workflows/yjit-ubuntu.yml
index a33a1c3c5d792b..45700224fa1b7f 100644
--- a/.github/workflows/yjit-ubuntu.yml
+++ b/.github/workflows/yjit-ubuntu.yml
@@ -147,7 +147,7 @@ jobs:
         if: ${{ matrix.rust_version }}
         run: rustup install ${{ matrix.rust_version }} --profile minimal
 
-      - uses: ruby/setup-ruby@7dc18ff0ca6e3630d3f29d2a85ebf6cc27ae9d6c # v1.177.0
+      - uses: ruby/setup-ruby@943103cae7d3f1bb1e4951d5fcc7928b40e4b742 # v1.177.1
         with:
           ruby-version: '3.0'
           bundler: none

From 5fa6ba9568e87e43e08a4daeba1572254c589fb1 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 23 May 2024 11:40:09 +0900
Subject: [PATCH 156/242] [Bug #20500] Search non-default directories for
 jemalloc

Co-Authored-by: lish82 (Hiroki Katagiri)
---
 configure.ac    | 4 ++++
 enc/Makefile.in | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index ef9a2b324799a4..a7fb1ab56d2831 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1388,6 +1388,8 @@ AC_ARG_WITH([jemalloc],
   [with_jemalloc=$withval], [with_jemalloc=no])
 AS_IF([test "x$with_jemalloc" != xno],[
   # find jemalloc header first
+  save_CPPFLAGS="${CPPFLAGS}"
+  CPPFLAGS="${INCFLAGS} ${CPPFLAGS}"
   malloc_header=
   AC_CHECK_HEADER(jemalloc/jemalloc.h, [malloc_header=jemalloc/jemalloc.h], [
     AC_CHECK_HEADER(jemalloc.h, [malloc_header=jemalloc.h])
@@ -1419,6 +1421,8 @@ AS_IF([test "x$with_jemalloc" != xno],[
       done
     done
   ])
+  CPPFLAGS="${save_CPPFLAGS}"
+  unset save_CPPFLAGS
   with_jemalloc=${rb_cv_jemalloc_library}
   AS_CASE(["$with_jemalloc"],
   [no],
diff --git a/enc/Makefile.in b/enc/Makefile.in
index 6920bc9520435a..ce93fdd22d2350 100644
--- a/enc/Makefile.in
+++ b/enc/Makefile.in
@@ -52,7 +52,7 @@ optflags = @optflags@
 debugflags = @debugflags@
 warnflags = @warnflags@
 CCDLFLAGS = @CCDLFLAGS@
-INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(top_srcdir)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(top_srcdir) @incflags@
 DEFS = @DEFS@
 CPPFLAGS = @CPPFLAGS@ -DONIG_ENC_REGISTER=rb_enc_register
 LDFLAGS = @LDFLAGS@

From ce20367a0e2f1fcfabebf3b6bea732fc71fa79f7 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 23 May 2024 12:35:09 +0900
Subject: [PATCH 157/242] Define `incflags` also on mswin

---
 win32/Makefile.sub | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/win32/Makefile.sub b/win32/Makefile.sub
index 7dbb020eee11fc..61cca108574dfa 100644
--- a/win32/Makefile.sub
+++ b/win32/Makefile.sub
@@ -160,6 +160,9 @@ OPTFLAGS = -O2b2xg-
 OPTFLAGS = -O2sy-
 !endif
 !endif
+!if !defined(incflags)
+incflags =
+!endif
 !if !defined(PLATFORM)
 PLATFORM = mswin32
 !endif
@@ -970,6 +973,7 @@ s,@WERRORFLAG@,$(WERRORFLAG),;t t
 s,@DEFS@,$(DEFS),;t t
 s,@CPPFLAGS@,$(CPPFLAGS),;t t
 s,@CXXFLAGS@,$(CXXFLAGS),;t t
+s,@incflags@,$(incflags),;t t
 s,@FFLAGS@,$(FFLAGS),;t t
 s,@LDFLAGS@,$(LDFLAGS),;t t
 s,@LIBS@,user32.lib,;t t

From 1471a160ba1bbdca9d6c4b21260793c1414253f3 Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Thu, 23 May 2024 18:24:48 +0900
Subject: [PATCH 158/242] Add RB_GC_GUARD for rb_str_to_parser_string

I think this fixes the following random test failure that could not be
fixed for a long time:

```
  1) Failure:
TestSymbol#test_inspect_under_gc_compact_stress [/home/chkbuild/chkbuild/tmp/build/20240522T003003Z/ruby/test/ruby/test_symbol.rb:126]:
<":testing"> expected but was
<":\"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"">.
```

The value passed to this function is the return value of `rb_id2str`, so
it is never collected.  However, if auto_compact is enabled, the string
may move and `RSTRING_PTR(str)` became invalid.

This change prevents the string from being moved by RB_GC_GUARD.
---
 parse.y | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/parse.y b/parse.y
index 9a2535bd2db4dc..2ce1143d204983 100644
--- a/parse.y
+++ b/parse.y
@@ -2082,7 +2082,9 @@ rb_parser_string_t *
 rb_str_to_parser_string(rb_parser_t *p, VALUE str)
 {
     /* Type check */
-    return rb_parser_encoding_string_new(p, RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
+    rb_parser_string_t *ret = rb_parser_encoding_string_new(p, RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
+    RB_GC_GUARD(str);
+    return ret;
 }
 #endif
 

From a99d79dd318d525ecf2335c7c7d652eed860e1f5 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 23 May 2024 18:19:30 +0900
Subject: [PATCH 159/242] Remove dead code

Since 140512d2225e6fd046ba1bdbcd1a27450f55c233, `else` without
`rescue` has been a syntax error.
---
 parse.y | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/parse.y b/parse.y
index 2ce1143d204983..a14f49a62e02d6 100644
--- a/parse.y
+++ b/parse.y
@@ -14943,9 +14943,6 @@ new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_els
         result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
         nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
     }
-    else if (rescue_else) {
-        result = block_append(p, result, rescue_else);
-    }
     if (ensure) {
         result = NEW_ENSURE(result, ensure, loc);
     }

From 7d89d52714bdde9ae369ff04020a96433bfd4d94 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 23 May 2024 11:28:32 -0400
Subject: [PATCH 160/242] [ruby/prism] Disallow newlines in heredoc identifiers

https://github.com/ruby/prism/commit/737f2c2117
---
 prism/prism.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/prism/prism.c b/prism/prism.c
index 5b27333f221188..86a4aa90b02a81 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -10949,6 +10949,7 @@ parser_lex(pm_parser_t *parser) {
                                     // If we have quotes, then we're going to go until we find the
                                     // end quote.
                                     while ((parser->current.end < parser->end) && quote != (pm_heredoc_quote_t) (*parser->current.end)) {
+                                        if (*parser->current.end == '\r' || *parser->current.end == '\n') break;
                                         parser->current.end++;
                                     }
                                 }

From 0ebd37234eacd0ab01535aed81a94e83339552a3 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 23 May 2024 11:53:22 -0400
Subject: [PATCH 161/242] [PRISM] Enable
 TestSyntax#test_unterminated_heredoc_cr

---
 test/.excludes-prism/TestSyntax.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index b07e2e1e0f4dfe..4e6f695ccf9281 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,5 +1,4 @@
 exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
-exclude(:test_unterminated_heredoc_cr, "quoted \r heredoc terminators should not match \r\n")
 
 exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")

From 56a51fcd33f6f3372ab889e7ddc2f20b89db81e2 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 23 May 2024 12:30:59 -0400
Subject: [PATCH 162/242] [PRISM] Fix up some masgn topn calculations

---
 prism_compile.c                        | 38 ++++++++++++--------------
 test/.excludes-prism/TestAssignment.rb |  1 -
 2 files changed, 18 insertions(+), 21 deletions(-)
 delete mode 100644 test/.excludes-prism/TestAssignment.rb

diff --git a/prism_compile.c b/prism_compile.c
index 5edc1ba2e7f49f..da7865fc8ca35c 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -3796,7 +3796,7 @@ pm_multi_target_state_update(pm_multi_target_state_t *state)
     }
 }
 
-static size_t
+static void
 pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const parents, LINK_ANCHOR *const writes, LINK_ANCHOR *const cleanup, pm_scope_node_t *scope_node, pm_multi_target_state_t *state);
 
 /**
@@ -4052,7 +4052,7 @@ pm_compile_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *cons
  * on the stack that correspond to the parent expressions of the various
  * targets.
  */
-static size_t
+static void
 pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const parents, LINK_ANCHOR *const writes, LINK_ANCHOR *const cleanup, pm_scope_node_t *scope_node, pm_multi_target_state_t *state)
 {
     const pm_line_column_t location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
@@ -4092,26 +4092,28 @@ pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR
     // going through the targets because we will need to revisit them once
     // we know how many values are being pushed onto the stack.
     pm_multi_target_state_t target_state = { 0 };
-    size_t base_position = state == NULL ? 0 : state->position;
+    if (state == NULL) state = &target_state;
+
+    size_t base_position = state->position;
     size_t splat_position = has_rest ? 1 : 0;
 
     // Next, we'll iterate through all of the leading targets.
     for (size_t index = 0; index < lefts->size; index++) {
         const pm_node_t *target = lefts->nodes[index];
-        target_state.position = lefts->size - index + splat_position + base_position;
-        pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, &target_state);
+        state->position = lefts->size - index + splat_position + base_position;
+        pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
     }
 
     // Next, we'll compile the rest target if there is one.
     if (has_rest) {
         const pm_node_t *target = ((const pm_splat_node_t *) rest)->expression;
-        target_state.position = 1 + rights->size + base_position;
+        state->position = 1 + rights->size + base_position;
 
         if (has_posts) {
             PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(3));
         }
 
-        pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, &target_state);
+        pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
     }
 
     // Finally, we'll compile the trailing targets.
@@ -4122,18 +4124,10 @@ pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR
 
         for (size_t index = 0; index < rights->size; index++) {
             const pm_node_t *target = rights->nodes[index];
-            target_state.position = rights->size - index + base_position;
-            pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, &target_state);
+            state->position = rights->size - index + base_position;
+            pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
         }
     }
-
-    // Now, we need to go back and modify the topn instructions in order to
-    // ensure they can correctly retrieve the parent expressions.
-    pm_multi_target_state_update(&target_state);
-
-    if (state != NULL) state->stack_size += target_state.stack_size;
-
-    return target_state.stack_size;
 }
 
 /**
@@ -7289,18 +7283,22 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
 
         pm_multi_target_state_t state = { 0 };
         state.position = popped ? 0 : 1;
-        size_t stack_size = pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
+        pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
 
         PM_COMPILE_NOT_POPPED(cast->value);
         if (!popped) PUSH_INSN(ret, location, dup);
 
         PUSH_SEQ(ret, writes);
-        if (!popped && stack_size >= 1) {
+        if (!popped && state.stack_size >= 1) {
             // Make sure the value on the right-hand side of the = operator is
             // being returned before we pop the parent expressions.
-            PUSH_INSN1(ret, location, setn, INT2FIX(stack_size));
+            PUSH_INSN1(ret, location, setn, INT2FIX(state.stack_size));
         }
 
+        // Now, we need to go back and modify the topn instructions in order to
+        // ensure they can correctly retrieve the parent expressions.
+        pm_multi_target_state_update(&state);
+
         PUSH_SEQ(ret, cleanup);
         return;
       }
diff --git a/test/.excludes-prism/TestAssignment.rb b/test/.excludes-prism/TestAssignment.rb
deleted file mode 100644
index 23a1b4c5e77e5f..00000000000000
--- a/test/.excludes-prism/TestAssignment.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_massign_order, "https://github.com/ruby/prism/issues/2370")

From e5e079e70f8b07697f7cc3f64736f993755500cb Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 23 May 2024 14:37:54 -0400
Subject: [PATCH 163/242] [ruby/prism] Only accept command call when specified
 for constant path

https://github.com/ruby/prism/commit/0ae908b6ee
---
 prism/prism.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prism/prism.c b/prism/prism.c
index 86a4aa90b02a81..5499ce4764d1f8 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -20714,7 +20714,7 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
 
                     if (
                         (parser->current.type == PM_TOKEN_PARENTHESIS_LEFT) ||
-                        (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR))
+                        (accepts_command_call && (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR)))
                     ) {
                         // If we have a constant immediately following a '::' operator, then
                         // this can either be a constant path or a method call, depending on

From 49fcd33e136ee2fe8720183b63a41bb6ef8d615c Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Thu, 23 May 2024 11:23:26 -0700
Subject: [PATCH 164/242] Introduce a specialize instruction for Array#pack

Instructions for this code:

```ruby
  # frozen_string_literal: true

[a].pack("C")
```

Before this commit:

```
== disasm: #<ISeq:<main>@test.rb:1 (1,0)-(3,13)>
0000 putself                                                          (   3)[Li]
0001 opt_send_without_block                 <calldata!mid:a, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 newarray                               1
0005 putobject                              "C"
0007 opt_send_without_block                 <calldata!mid:pack, argc:1, ARGS_SIMPLE>
0009 leave
```

After this commit:

```
== disasm: #<ISeq:<main>@test.rb:1 (1,0)-(3,13)>
0000 putself                                                          (   3)[Li]
0001 opt_send_without_block                 <calldata!mid:a, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 putobject                              "C"
0005 opt_newarray_send                      2, :pack
0008 leave
```

Co-authored-by: Maxime Chevalier-Boisvert <maxime.chevalierboisvert@shopify.com>
Co-authored-by: Aaron Patterson <tenderlove@ruby-lang.org>
---
 array.c                        | 13 ++++++++++++
 compile.c                      | 29 +++++++++++++++++++++----
 defs/id.def                    |  1 +
 insns.def                      |  3 +++
 internal/basic_operators.h     |  1 +
 pack.c                         |  6 ++++++
 rjit_c.c                       |  1 +
 rjit_c.rb                      |  4 ++++
 test/ruby/test_pack.rb         | 18 ++++++++++++++++
 tool/rjit/bindgen.rb           |  1 +
 vm.c                           |  1 +
 vm_insnhelper.c                | 16 ++++++++++++++
 yjit/src/codegen.rs            | 39 ++++++++++++++++++++++++++++++++++
 yjit/src/cruby.rs              |  1 +
 yjit/src/cruby_bindings.inc.rs |  3 ++-
 15 files changed, 132 insertions(+), 5 deletions(-)

diff --git a/array.c b/array.c
index 6ad69dd23fa791..8355a45da51c02 100644
--- a/array.c
+++ b/array.c
@@ -880,6 +880,19 @@ rb_ary_free(VALUE ary)
     }
 }
 
+VALUE
+rb_setup_fake_ary(struct RArray *fake_ary, const VALUE *list, long len, bool freeze)
+{
+    fake_ary->basic.flags = T_ARRAY;
+    VALUE ary = (VALUE)fake_ary;
+    RBASIC_CLEAR_CLASS(ary);
+    ARY_SET_PTR(ary, list);
+    ARY_SET_HEAP_LEN(ary, len);
+    ARY_SET_CAPA(ary, len);
+    if (freeze) OBJ_FREEZE(ary);
+    return ary;
+}
+
 size_t
 rb_ary_memsize(VALUE ary)
 {
diff --git a/compile.c b/compile.c
index 5167f4d61c3b75..bdccd36cf58344 100644
--- a/compile.c
+++ b/compile.c
@@ -4048,6 +4048,8 @@ insn_set_specialized_instruction(rb_iseq_t *iseq, INSN *iobj, int insn_id)
     return COMPILE_OK;
 }
 
+#define vm_ci_simple(ci) (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)
+
 static int
 iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
 {
@@ -4059,24 +4061,43 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
         INSN *niobj = (INSN *)iobj->link.next;
         if (IS_INSN_ID(niobj, send)) {
             const struct rb_callinfo *ci = (struct rb_callinfo *)OPERAND_AT(niobj, 0);
-            if ((vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE) && vm_ci_argc(ci) == 0) {
+            if (vm_ci_simple(ci) && vm_ci_argc(ci) == 0) {
                 switch (vm_ci_mid(ci)) {
                   case idMax:
                   case idMin:
                   case idHash:
                     {
                         VALUE num = iobj->operands[0];
+                        int operand_len = insn_len(BIN(opt_newarray_send)) - 1;
                         iobj->insn_id = BIN(opt_newarray_send);
-                        iobj->operands = compile_data_calloc2(iseq, insn_len(iobj->insn_id) - 1, sizeof(VALUE));
+                        iobj->operands = compile_data_calloc2(iseq, operand_len, sizeof(VALUE));
                         iobj->operands[0] = num;
                         iobj->operands[1] = rb_id2sym(vm_ci_mid(ci));
-                        iobj->operand_size = insn_len(iobj->insn_id) - 1;
+                        iobj->operand_size = operand_len;
                         ELEM_REMOVE(&niobj->link);
                         return COMPILE_OK;
                     }
                 }
             }
         }
+        else if ((IS_INSN_ID(niobj, putstring) ||
+                  (IS_INSN_ID(niobj, putobject) && RB_TYPE_P(OPERAND_AT(niobj, 0), T_STRING))) &&
+                 IS_NEXT_INSN_ID(&niobj->link, send)) {
+            const struct rb_callinfo *ci = (struct rb_callinfo *)OPERAND_AT((INSN *)niobj->link.next, 0);
+            if (vm_ci_simple(ci) && vm_ci_argc(ci) == 1 && vm_ci_mid(ci) == idPack) {
+                VALUE num = iobj->operands[0];
+                int operand_len = insn_len(BIN(opt_newarray_send)) - 1;
+                iobj->insn_id = BIN(opt_newarray_send);
+                iobj->operands = compile_data_calloc2(iseq, operand_len, sizeof(VALUE));
+                iobj->operands[0] = FIXNUM_INC(num, 1);
+                iobj->operands[1] = rb_id2sym(vm_ci_mid(ci));
+                iobj->operand_size = operand_len;
+                ELEM_REMOVE(&iobj->link);
+                ELEM_REMOVE(niobj->link.next);
+                ELEM_INSERT_NEXT(&niobj->link, &iobj->link);
+                return COMPILE_OK;
+            }
+        }
     }
 
     if (IS_INSN_ID(iobj, send)) {
@@ -4084,7 +4105,7 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
         const rb_iseq_t *blockiseq = (rb_iseq_t *)OPERAND_AT(iobj, 1);
 
 #define SP_INSN(opt) insn_set_specialized_instruction(iseq, iobj, BIN(opt_##opt))
-        if (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE) {
+        if (vm_ci_simple(ci)) {
             switch (vm_ci_argc(ci)) {
               case 0:
                 switch (vm_ci_mid(ci)) {
diff --git a/defs/id.def b/defs/id.def
index 2ddde7be70702a..71baa4f968d3bf 100644
--- a/defs/id.def
+++ b/defs/id.def
@@ -59,6 +59,7 @@ firstline, predefined = __LINE__+1, %[\
   name
   nil
   path
+  pack
 
   _                                                     UScore
 
diff --git a/insns.def b/insns.def
index 9c649904b88278..3858ad3c6d66b4 100644
--- a/insns.def
+++ b/insns.def
@@ -977,6 +977,9 @@ opt_newarray_send
       case idMax:
         val = vm_opt_newarray_max(ec, num, STACK_ADDR_FROM_TOP(num));
         break;
+      case idPack:
+        val = rb_vm_opt_newarray_pack(ec, (long)num-1, STACK_ADDR_FROM_TOP(num), TOPN(0));
+        break;
       default:
         rb_bug("unreachable");
     }
diff --git a/internal/basic_operators.h b/internal/basic_operators.h
index a59403631ef5ba..4732a654038af4 100644
--- a/internal/basic_operators.h
+++ b/internal/basic_operators.h
@@ -37,6 +37,7 @@ enum ruby_basic_operators {
     BOP_OR,
     BOP_CMP,
     BOP_DEFAULT,
+    BOP_PACK,
 
     BOP_LAST_
 };
diff --git a/pack.c b/pack.c
index 4fdaf7fd897352..1b0d66f9900995 100644
--- a/pack.c
+++ b/pack.c
@@ -782,6 +782,12 @@ pack_pack(rb_execution_context_t *ec, VALUE ary, VALUE fmt, VALUE buffer)
     return res;
 }
 
+VALUE
+rb_ec_pack_ary(rb_execution_context_t *ec, VALUE ary, VALUE fmt, VALUE buffer)
+{
+    return pack_pack(ec, ary, fmt, buffer);
+}
+
 static const char uu_table[] =
 "`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
 static const char b64_table[] =
diff --git a/rjit_c.c b/rjit_c.c
index e6d8d5da5c2040..e9863129a1c767 100644
--- a/rjit_c.c
+++ b/rjit_c.c
@@ -519,6 +519,7 @@ extern VALUE rb_vm_getclassvariable(const rb_iseq_t *iseq, const rb_control_fram
 extern VALUE rb_vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr);
 extern VALUE rb_vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr);
 extern VALUE rb_vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr);
+extern VALUE rb_vm_opt_newarray_pack(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr, VALUE fmt);
 extern VALUE rb_vm_splat_array(VALUE flag, VALUE array);
 extern bool rb_simple_iseq_p(const rb_iseq_t *iseq);
 extern bool rb_vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type, VALUE obj, VALUE v);
diff --git a/rjit_c.rb b/rjit_c.rb
index b9a5bb0b5532bc..f6d48261354ef9 100644
--- a/rjit_c.rb
+++ b/rjit_c.rb
@@ -691,6 +691,10 @@ def C.rb_vm_opt_newarray_min
     Primitive.cexpr! %q{ SIZET2NUM((size_t)rb_vm_opt_newarray_min) }
   end
 
+  def C.rb_vm_opt_newarray_pack
+    Primitive.cexpr! %q{ SIZET2NUM((size_t)rb_vm_opt_newarray_pack) }
+  end
+
   def C.rb_vm_set_ivar_id
     Primitive.cexpr! %q{ SIZET2NUM((size_t)rb_vm_set_ivar_id) }
   end
diff --git a/test/ruby/test_pack.rb b/test/ruby/test_pack.rb
index 1ce46e8916bc70..a0c66c188b6e12 100644
--- a/test/ruby/test_pack.rb
+++ b/test/ruby/test_pack.rb
@@ -895,4 +895,22 @@ def test_unpack_offset
     }
     assert_equal [nil], "a".unpack("C", offset: 1)
   end
+
+  def test_monkey_pack
+    assert_separately([], <<-'end;')
+      $-w = false
+      class Array
+        alias :old_pack :pack
+        def pack _; "oh no"; end
+      end
+
+      v = [2 ** 15].pack('n')
+
+      class Array
+        alias :pack :old_pack
+      end
+
+      assert_equal "oh no", v
+    end;
+  end
 end
diff --git a/tool/rjit/bindgen.rb b/tool/rjit/bindgen.rb
index fb6653ed9c8649..2fc45762161ba1 100755
--- a/tool/rjit/bindgen.rb
+++ b/tool/rjit/bindgen.rb
@@ -540,6 +540,7 @@ def push_target(target)
     rb_vm_opt_newarray_min
     rb_vm_opt_newarray_max
     rb_vm_opt_newarray_hash
+    rb_vm_opt_newarray_pack
     rb_vm_setinstancevariable
     rb_vm_splat_array
     rjit_full_cfunc_return
diff --git a/vm.c b/vm.c
index 7e3994001717db..550ded3209d79c 100644
--- a/vm.c
+++ b/vm.c
@@ -2278,6 +2278,7 @@ vm_redefinition_bop_for_id(ID mid)
     OP(NilP, NIL_P);
     OP(Cmp, CMP);
     OP(Default, DEFAULT);
+    OP(Pack, PACK);
 #undef OP
     }
     return -1;
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index a1893b1ba239f4..1e1fcea120255e 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -5932,6 +5932,22 @@ rb_vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t num, const VALUE *p
     return vm_opt_newarray_hash(ec, num, ptr);
 }
 
+VALUE rb_setup_fake_ary(struct RArray *fake_ary, const VALUE *list, long len, bool freeze);
+VALUE rb_ec_pack_ary(rb_execution_context_t *ec, VALUE ary, VALUE fmt, VALUE buffer);
+
+VALUE
+rb_vm_opt_newarray_pack(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr, VALUE fmt)
+{
+    if (BASIC_OP_UNREDEFINED_P(BOP_PACK, ARRAY_REDEFINED_OP_FLAG)) {
+        struct RArray fake_ary;
+        VALUE ary = rb_setup_fake_ary(&fake_ary, ptr, num, true);
+        return rb_ec_pack_ary(ec, ary, fmt, Qnil);
+    }
+    else {
+        return rb_vm_call_with_refinements(ec, rb_ary_new4(num, ptr), idPack, 1, &fmt, RB_PASS_CALLED_KEYWORDS);
+    }
+}
+
 #undef id_cmp
 
 #define IMEMO_CONST_CACHE_SHAREABLE IMEMO_FL_USER0
diff --git a/yjit/src/codegen.rs b/yjit/src/codegen.rs
index 072d96f1b09e82..747fa1769d2537 100644
--- a/yjit/src/codegen.rs
+++ b/yjit/src/codegen.rs
@@ -4235,11 +4235,50 @@ fn gen_opt_newarray_send(
         gen_opt_newarray_max(jit, asm, _ocb)
     } else if method == ID!(hash) {
         gen_opt_newarray_hash(jit, asm, _ocb)
+    } else if method == ID!(pack) {
+        gen_opt_newarray_pack(jit, asm, _ocb)
     } else {
         None
     }
 }
 
+fn gen_opt_newarray_pack(
+    jit: &mut JITState,
+    asm: &mut Assembler,
+    _ocb: &mut OutlinedCb,
+) -> Option<CodegenStatus> {
+    // num == 4 ( for this code )
+    let num = jit.get_arg(0).as_u32();
+
+    // Save the PC and SP because we may call #pack
+    jit_prepare_non_leaf_call(jit, asm);
+
+    extern "C" {
+        fn rb_vm_opt_newarray_pack(ec: EcPtr, num: u32, elts: *const VALUE, fmt: VALUE) -> VALUE;
+    }
+
+    let values_opnd = asm.ctx.sp_opnd(-(num as i32));
+    let values_ptr = asm.lea(values_opnd);
+
+    let fmt_string = asm.ctx.sp_opnd(-1);
+
+    let val_opnd = asm.ccall(
+        rb_vm_opt_newarray_pack as *const u8,
+        vec![
+            EC,
+            (num - 1).into(),
+            values_ptr,
+            fmt_string
+        ],
+    );
+
+    asm.stack_pop(num.as_usize());
+    let stack_ret = asm.stack_push(Type::CString);
+    asm.mov(stack_ret, val_opnd);
+
+    Some(KeepCompiling)
+}
+
 fn gen_opt_newarray_hash(
     jit: &mut JITState,
     asm: &mut Assembler,
diff --git a/yjit/src/cruby.rs b/yjit/src/cruby.rs
index 68c0304b06b0de..53586cb4f4c5b0 100644
--- a/yjit/src/cruby.rs
+++ b/yjit/src/cruby.rs
@@ -802,6 +802,7 @@ pub(crate) mod ids {
         name: min                content: b"min"
         name: max                content: b"max"
         name: hash               content: b"hash"
+        name: pack               content: b"pack"
         name: respond_to_missing content: b"respond_to_missing?"
         name: to_ary             content: b"to_ary"
         name: eq                 content: b"=="
diff --git a/yjit/src/cruby_bindings.inc.rs b/yjit/src/cruby_bindings.inc.rs
index a03c2d0f0011ee..d53e630a4a56fb 100644
--- a/yjit/src/cruby_bindings.inc.rs
+++ b/yjit/src/cruby_bindings.inc.rs
@@ -342,7 +342,8 @@ pub const BOP_AND: ruby_basic_operators = 28;
 pub const BOP_OR: ruby_basic_operators = 29;
 pub const BOP_CMP: ruby_basic_operators = 30;
 pub const BOP_DEFAULT: ruby_basic_operators = 31;
-pub const BOP_LAST_: ruby_basic_operators = 32;
+pub const BOP_PACK: ruby_basic_operators = 32;
+pub const BOP_LAST_: ruby_basic_operators = 33;
 pub type ruby_basic_operators = u32;
 pub type rb_serial_t = ::std::os::raw::c_ulonglong;
 pub const imemo_env: imemo_type = 0;

From c96b5791efd7d14c7387adea9c6c252d7ecbb231 Mon Sep 17 00:00:00 2001
From: eileencodes <eileencodes@gmail.com>
Date: Mon, 13 May 2024 17:10:22 -0400
Subject: [PATCH 165/242] [ruby/prism] Raise `void value expression` in begin
 clauses

In some cases Prism was either not raising an appropriate `void value
expression` error, or raising that error when the syntax is considered
valid.

To fix this Prism needs to check whether we have other clauses on the
`begin` rather than just returning `cast->statements`.

* If the `cast->statements` are null and the `cast->ensure_clause` is
not null, set the code to `cast->ensure_clause`
* else
  * If there is a `cast->rescue_clause`
    * Check if `cast->statements` are null and `cast->rescue_clause->statements`
    are null, and return `NULL`
    * Check if there is an `else_clause`, and set the node to
      `cast->else_clause`.
    * Otherwise return `cast->statements` as the node
  * return `cast->statements` as the node

See tests for test cases. Note I took these directly from CRuby so if
desired I can delete them since the test will now pass. This only fixes
one test in the `test_parse` file, taking failures from 14 to 13.

This fixes `TestParse#test_void_value_in_rhs` and is related to
issue #2791.

https://github.com/ruby/prism/commit/398152b412
---
 prism/prism.c             | 25 +++++++++++++++++++++++++
 test/prism/errors_test.rb | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+)

diff --git a/prism/prism.c b/prism/prism.c
index 5499ce4764d1f8..6d0dd6b66f4e94 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -1183,6 +1183,31 @@ pm_check_value_expression(pm_node_t *node) {
                 return NULL;
             case PM_BEGIN_NODE: {
                 pm_begin_node_t *cast = (pm_begin_node_t *) node;
+
+                if (cast->statements == NULL && cast->ensure_clause != NULL) {
+                    node = (pm_node_t *) cast->ensure_clause;
+                }
+                else {
+                    if (cast->rescue_clause != NULL) {
+                        if (cast->rescue_clause->statements == NULL) {
+                            return NULL;
+                        }
+                        else if (cast->else_clause != NULL) {
+                            node = (pm_node_t *) cast->else_clause;
+                        }
+                        else {
+                            node = (pm_node_t *) cast->statements;
+                        }
+                    }
+                    else {
+                        node = (pm_node_t *) cast->statements;
+                    }
+                }
+
+                break;
+            }
+            case PM_ENSURE_NODE: {
+                pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
                 node = (pm_node_t *) cast->statements;
                 break;
             }
diff --git a/test/prism/errors_test.rb b/test/prism/errors_test.rb
index 50417e476e7dc7..5f4acb01201619 100644
--- a/test/prism/errors_test.rb
+++ b/test/prism/errors_test.rb
@@ -1630,6 +1630,41 @@ class << (return)
       ]
     end
 
+    def test_void_value_expression_in_begin_statement
+      source = <<~RUBY
+        x = return 1
+        x = return, 1
+        x = 1, return
+        x, y = return
+        x = begin return ensure end
+        x = begin ensure return end
+        x = begin return ensure return end
+        x = begin return; rescue; return end
+        x = begin return; rescue; return; else return end
+        x = begin; return; rescue; retry; end
+      RUBY
+
+      message = 'unexpected void value expression'
+      assert_errors expression(source), source, [
+        [message, 4..12],
+        [message, 17..23],
+        [message, 34..40],
+        [message, 48..54],
+        [message, 65..71],
+        [message, 100..106],
+        [message, 121..127],
+        [message, 156..162],
+        [message, 222..228],
+        [message, 244..250],
+      ]
+
+      refute_error_messages("x = begin return; rescue; end")
+      refute_error_messages("x = begin return; rescue; return; else end")
+      refute_error_messages("x = begin; rescue; retry; end")
+      refute_error_messages("x = begin 1; rescue; retry; ensure; end")
+      refute_error_messages("x = begin 1; rescue; return; end")
+    end
+
     def test_void_value_expression_in_def
       source = <<~RUBY
         def (return).x

From 76e31d9aa93ce624a8f74db57af488c74017b7f3 Mon Sep 17 00:00:00 2001
From: Martin Emde <me@martinemde.com>
Date: Tue, 21 May 2024 16:19:51 -0700
Subject: [PATCH 166/242] [rubygems/rubygems] Remove MD5 ETag generation from
 compact index

This was an offramp for generated etags to allow existing caches
to be served until people could upgrade. It has been about 6 months
since the transitional version was released, so we can remove this
transitional code now.

https://github.com/rubygems/rubygems/commit/4ec8cfe611
---
 lib/bundler/compact_index_client/cache_file.rb |  5 -----
 lib/bundler/compact_index_client/updater.rb    | 11 -----------
 .../compact_index_client/updater_spec.rb       | 18 +-----------------
 3 files changed, 1 insertion(+), 33 deletions(-)

diff --git a/lib/bundler/compact_index_client/cache_file.rb b/lib/bundler/compact_index_client/cache_file.rb
index 5988bc91b3bac4..299d683438b887 100644
--- a/lib/bundler/compact_index_client/cache_file.rb
+++ b/lib/bundler/compact_index_client/cache_file.rb
@@ -86,11 +86,6 @@ def digests=(expected_digests)
         end
       end
 
-      # remove this method when we stop generating md5 digests for legacy etags
-      def md5
-        @digests && @digests["md5"]
-      end
-
       def digests?
         @digests&.any?
       end
diff --git a/lib/bundler/compact_index_client/updater.rb b/lib/bundler/compact_index_client/updater.rb
index 36f6b81db890d4..88c7146900bfd7 100644
--- a/lib/bundler/compact_index_client/updater.rb
+++ b/lib/bundler/compact_index_client/updater.rb
@@ -28,7 +28,6 @@ def append(remote_path, local_path, etag_path)
 
         CacheFile.copy(local_path) do |file|
           etag = etag_path.read.tap(&:chomp!) if etag_path.file?
-          etag ||= generate_etag(etag_path, file) # Remove this after 2.5.0 has been out for a while.
 
           # Subtract a byte to ensure the range won't be empty.
           # Avoids 416 (Range Not Satisfiable) responses.
@@ -67,16 +66,6 @@ def etag_for_request(etag_path)
         etag_path.read.tap(&:chomp!) if etag_path.file?
       end
 
-      # When first releasing this opaque etag feature, we want to generate the old MD5 etag
-      # based on the content of the file. After that it will always use the saved opaque etag.
-      # This transparently saves existing users with good caches from updating a bunch of files.
-      # Remove this behavior after 2.5.0 has been out for a while.
-      def generate_etag(etag_path, file)
-        etag = file.md5.hexdigest
-        CacheFile.write(etag_path, etag)
-        etag
-      end
-
       def etag_from_response(response)
         return unless response["ETag"]
         etag = response["ETag"].delete_prefix("W/")
diff --git a/spec/bundler/bundler/compact_index_client/updater_spec.rb b/spec/bundler/bundler/compact_index_client/updater_spec.rb
index 6eed88ca9e5836..87a73d993f614a 100644
--- a/spec/bundler/bundler/compact_index_client/updater_spec.rb
+++ b/spec/bundler/bundler/compact_index_client/updater_spec.rb
@@ -119,23 +119,7 @@
 
     context "without an etag file" do
       let(:headers) do
-        {
-          "Range" => "bytes=2-",
-          # This MD5 feature should be deleted after sufficient time has passed since release.
-          # From then on, requests that still don't have a saved etag will be made without this header.
-          "If-None-Match" => %("#{Digest::MD5.hexdigest(local_body)}"),
-        }
-      end
-
-      it "saves only the etag_path if generated etag matches" do
-        expect(fetcher).to receive(:call).once.with(remote_path, headers).and_return(response)
-        allow(response).to receive(:is_a?).with(Gem::Net::HTTPPartialContent) { false }
-        allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified) { true }
-
-        updater.update(remote_path, local_path, etag_path)
-
-        expect(local_path.read).to eq("abc")
-        expect(%("#{etag_path.read}")).to eq(headers["If-None-Match"])
+        { "Range" => "bytes=2-" }
       end
 
       it "appends the file" do

From 2d4d99f78aa846b21f05508ab73172b24bd08954 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Thu, 23 May 2024 15:31:18 -0400
Subject: [PATCH 167/242] [PRISM] Update remaining test excludes

---
 test/.excludes-prism/TestM17N.rb               | 2 +-
 test/.excludes-prism/TestMixedUnicodeEscape.rb | 2 +-
 test/.excludes-prism/TestParse.rb              | 1 -
 test/.excludes-prism/TestRubyLiteral.rb        | 2 +-
 test/.excludes-prism/TestSyntax.rb             | 3 +--
 5 files changed, 4 insertions(+), 6 deletions(-)
 delete mode 100644 test/.excludes-prism/TestParse.rb

diff --git a/test/.excludes-prism/TestM17N.rb b/test/.excludes-prism/TestM17N.rb
index 0367ffa9f2da88..7f8c44d02a93bb 100644
--- a/test/.excludes-prism/TestM17N.rb
+++ b/test/.excludes-prism/TestM17N.rb
@@ -1 +1 @@
-exclude(:test_regexp_usascii, "x80 should raise syntax error")
+exclude(:test_regexp_usascii, "https://bugs.ruby-lang.org/issues/20504")
diff --git a/test/.excludes-prism/TestMixedUnicodeEscape.rb b/test/.excludes-prism/TestMixedUnicodeEscape.rb
index 753c119d147520..7bf964ebf14961 100644
--- a/test/.excludes-prism/TestMixedUnicodeEscape.rb
+++ b/test/.excludes-prism/TestMixedUnicodeEscape.rb
@@ -1 +1 @@
-exclude(:test_basic, "should raise mixed encoding error")
+exclude(:test_basic, "https://bugs.ruby-lang.org/issues/20504")
diff --git a/test/.excludes-prism/TestParse.rb b/test/.excludes-prism/TestParse.rb
deleted file mode 100644
index f0b7118624f506..00000000000000
--- a/test/.excludes-prism/TestParse.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_void_value_in_rhs, "missing raising error for some void value expressions")
diff --git a/test/.excludes-prism/TestRubyLiteral.rb b/test/.excludes-prism/TestRubyLiteral.rb
index a25e1c47d91cb5..853f23a3b9baf8 100644
--- a/test/.excludes-prism/TestRubyLiteral.rb
+++ b/test/.excludes-prism/TestRubyLiteral.rb
@@ -1 +1 @@
-exclude(:test_dregexp, "x80 should raise syntax error")
+exclude(:test_dregexp, "https://bugs.ruby-lang.org/issues/20504")
diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index 4e6f695ccf9281..ab672d19a6aef8 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,5 +1,4 @@
-exclude(:test_dedented_heredoc_continued_line, "heredoc line continuation dedent calculation")
-
+exclude(:test_dedented_heredoc_continued_line, "https://bugs.ruby-lang.org/issues/20503")
 exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")
 exclude(:test_keyword_self_reference, "https://bugs.ruby-lang.org/issues/20478")

From acdd19facc0cfe18875d1f053689cbfc317f37c1 Mon Sep 17 00:00:00 2001
From: Martin Emde <me@martinemde.com>
Date: Thu, 23 May 2024 16:36:11 -0700
Subject: [PATCH 168/242] [rubygems/rubygems] Fiks speeling cott bye codespell

https://github.com/rubygems/rubygems/commit/508ed917a5
---
 lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt b/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
index 175b821a62731d..6a46aba8df62c5 100644
--- a/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
+++ b/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
@@ -2,7 +2,7 @@
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
 
 We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
 

From e49d68bf2732cf467a1532283de4a1716e238677 Mon Sep 17 00:00:00 2001
From: Sampat Badhe <sampatbadhe@gmail.com>
Date: Fri, 24 May 2024 11:45:51 +0530
Subject: [PATCH 169/242] correct typo [ci skip]

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index c055d14f8d124f..9ec9448d89747c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -124,7 +124,7 @@ See GitHub releases like [GitHub Releases of Logger](https://github.com/ruby/log
   a warning on verbose mode (`-w`).
   [[Feature #15554]]
 
-* Redefining some core methods that are specially optimized by the interpeter
+* Redefining some core methods that are specially optimized by the interpreter
   and JIT like `String.freeze` or `Integer#+` now emits a performance class
   warning (`-W:performance` or `Warning[:performance] = true`).
   [[Feature #20429]]

From 3832a1bda831da2074a3a5f8aa89c10244ae9316 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 15:57:31 +0200
Subject: [PATCH 170/242] [rubygems/rubygems] Make code more symmetric

https://github.com/rubygems/rubygems/commit/dc7c9f029a
---
 lib/bundler/installer.rb | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index 72e5602cc31284..e26ca82d0629fb 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -237,13 +237,12 @@ def install_in_parallel(size, standalone, force = false)
     def resolve_if_needed(options)
       @definition.resolution_mode = options
 
-      if !@definition.unlocking? && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file?
-        return false if @definition.nothing_changed? && !@definition.missing_specs?
+      if !@definition.unlocking? && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file? && @definition.nothing_changed? && !@definition.missing_specs?
+        false
+      else
+        @definition.setup_sources_for_resolve
+        true
       end
-
-      @definition.setup_sources_for_resolve
-
-      true
     end
 
     def lock

From 0f9781b5c1a17e7b57d3e23700896dce3bcf2404 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 19:31:12 +0200
Subject: [PATCH 171/242] [rubygems/rubygems] Use
 `Definition#no_resolve_needed?`

https://github.com/rubygems/rubygems/commit/5074c58ffb
---
 lib/bundler/installer.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index e26ca82d0629fb..406c7474d5ca20 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -237,7 +237,7 @@ def install_in_parallel(size, standalone, force = false)
     def resolve_if_needed(options)
       @definition.resolution_mode = options
 
-      if !@definition.unlocking? && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file? && @definition.nothing_changed? && !@definition.missing_specs?
+      if !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file? && @definition.no_resolve_needed? && !@definition.missing_specs?
         false
       else
         @definition.setup_sources_for_resolve

From ea7e3e7b789885fe01779b21749526e20d184e82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 19:47:23 +0200
Subject: [PATCH 172/242] [rubygems/rubygems] Give better message when
 resolving because there's no lockfile

https://github.com/rubygems/rubygems/commit/4e048bc255
---
 lib/bundler/definition.rb | 9 ++++++++-
 lib/bundler/installer.rb  | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb
index 22070b6b177128..bc526fa3e3b1bd 100644
--- a/lib/bundler/definition.rb
+++ b/lib/bundler/definition.rb
@@ -310,7 +310,12 @@ def resolve
           end
         end
       else
-        Bundler.ui.debug "Found changes from the lockfile, re-resolving dependencies because #{change_reason}"
+        if lockfile_exists?
+          Bundler.ui.debug "Found changes from the lockfile, re-resolving dependencies because #{change_reason}"
+        else
+          Bundler.ui.debug "Resolving dependencies because there's no lockfile"
+        end
+
         start_resolution
       end
     end
@@ -483,6 +488,8 @@ def most_specific_locked_platform
     private :sources
 
     def nothing_changed?
+      return false unless lockfile_exists?
+
       !@source_changes &&
         !@dependency_changes &&
         !@new_platform &&
diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index 406c7474d5ca20..433914d6448b07 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -237,7 +237,7 @@ def install_in_parallel(size, standalone, force = false)
     def resolve_if_needed(options)
       @definition.resolution_mode = options
 
-      if !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file? && @definition.no_resolve_needed? && !@definition.missing_specs?
+      if !options["force"] && !Bundler.settings[:inline] && @definition.no_resolve_needed? && !@definition.missing_specs?
         false
       else
         @definition.setup_sources_for_resolve

From c23798c2c47d531d6ed9a8557899b6f582ea6e1b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 20:51:30 +0200
Subject: [PATCH 173/242] [rubygems/rubygems] Remove `@remote` instance
 variable from Definition

It's a sources specific concern, so keep it there. It allows to simplify
the code quite a lot.

https://github.com/rubygems/rubygems/commit/639f0b72f4
---
 lib/bundler/definition.rb  | 28 +++++-----------------------
 lib/bundler/installer.rb   |  7 ++++---
 lib/bundler/source_list.rb |  7 +++++++
 3 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb
index bc526fa3e3b1bd..5c9437a83c2a9c 100644
--- a/lib/bundler/definition.rb
+++ b/lib/bundler/definition.rb
@@ -69,7 +69,6 @@ def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, opti
       @sources         = sources
       @unlock          = unlock
       @optional_groups = optional_groups
-      @remote          = false
       @prefer_local    = false
       @specs           = nil
       @ruby_version    = ruby_version
@@ -164,7 +163,6 @@ def gem_version_promoter
     end
 
     def resolve_only_locally!
-      @remote = false
       sources.local_only!
       resolve
     end
@@ -175,26 +173,12 @@ def resolve_with_cache!
     end
 
     def resolve_remotely!
-      @remote = true
       sources.remote!
       resolve
     end
 
-    def resolution_mode=(options)
-      if options["local"]
-        @remote = false
-      else
-        @remote = true
-        @prefer_local = options["prefer-local"]
-      end
-    end
-
-    def setup_sources_for_resolve
-      if @remote == false
-        sources.cached!
-      else
-        sources.remote!
-      end
+    def prefer_local!
+      @prefer_local = true
     end
 
     # For given dependency list returns a SpecSet with Gemspec of all the required
@@ -594,7 +578,7 @@ def materialize(dependencies)
       if missing_specs.any?
         missing_specs.each do |s|
           locked_gem = @locked_specs[s.name].last
-          next if locked_gem.nil? || locked_gem.version != s.version || !@remote
+          next if locked_gem.nil? || locked_gem.version != s.version || sources.local_mode?
           raise GemNotFound, "Your bundle is locked to #{locked_gem} from #{locked_gem.source}, but that version can " \
                              "no longer be found in that source. That means the author of #{locked_gem} has removed it. " \
                              "You'll need to update your bundle to a version other than #{locked_gem} that hasn't been " \
@@ -613,7 +597,7 @@ def materialize(dependencies)
         break if incomplete_specs.empty?
 
         Bundler.ui.debug("The lockfile does not have all gems needed for the current platform though, Bundler will still re-resolve dependencies")
-        setup_sources_for_resolve
+        sources.remote!
         resolution_packages.delete(incomplete_specs)
         @resolve = start_resolution
         specs = resolve.materialize(dependencies)
@@ -974,7 +958,7 @@ def source_requirements
       else
         { default: Source::RubygemsAggregate.new(sources, source_map) }.merge(source_map.direct_requirements)
       end
-      source_requirements.merge!(source_map.locked_requirements) unless @remote
+      source_requirements.merge!(source_map.locked_requirements) if nothing_changed?
       metadata_dependencies.each do |dep|
         source_requirements[dep.name] = sources.metadata_source
       end
@@ -1045,8 +1029,6 @@ def additional_base_requirements_to_force_updates(resolution_packages)
 
     def dup_for_full_unlock
       unlocked_definition = self.class.new(@lockfile, @dependencies, @sources, true, @ruby_version, @optional_groups, @gemfiles)
-      unlocked_definition.resolution_mode = { "local" => !@remote }
-      unlocked_definition.setup_sources_for_resolve
       unlocked_definition.gem_version_promoter.tap do |gvp|
         gvp.level = gem_version_promoter.level
         gvp.strict = gem_version_promoter.strict
diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index 433914d6448b07..1c5ed7c048a637 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -235,12 +235,13 @@ def install_in_parallel(size, standalone, force = false)
 
     # returns whether or not a re-resolve was needed
     def resolve_if_needed(options)
-      @definition.resolution_mode = options
+      @definition.prefer_local! if options["prefer-local"]
 
-      if !options["force"] && !Bundler.settings[:inline] && @definition.no_resolve_needed? && !@definition.missing_specs?
+      if options["local"] || (!options["force"] && !Bundler.settings[:inline] && @definition.no_resolve_needed? && !@definition.missing_specs?)
+        @definition.resolve_with_cache!
         false
       else
-        @definition.setup_sources_for_resolve
+        @definition.resolve_remotely!
         true
       end
     end
diff --git a/lib/bundler/source_list.rb b/lib/bundler/source_list.rb
index bbaac33a953af9..ece2177d49b6eb 100644
--- a/lib/bundler/source_list.rb
+++ b/lib/bundler/source_list.rb
@@ -22,6 +22,7 @@ def initialize
       @metadata_source        = Source::Metadata.new
 
       @merged_gem_lockfile_sections = false
+      @local_mode = true
     end
 
     def merged_gem_lockfile_sections?
@@ -73,6 +74,10 @@ def add_global_rubygems_remote(uri)
       global_rubygems_source
     end
 
+    def local_mode?
+      @local_mode
+    end
+
     def default_source
       global_path_source || global_rubygems_source
     end
@@ -145,6 +150,8 @@ def cached!
     end
 
     def remote!
+      @local_mode = false
+
       all_sources.each(&:remote!)
     end
 

From 744dd5a362eca2000eadb1873e7c0118aef97fe4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 21:08:53 +0200
Subject: [PATCH 174/242] [rubygems/rubygems] Fix performance regression on
 applications with a local cache

Even if all gems are properly installed and no resolve is needed, we
recently started always reading all packages in `vendor/cache` and
extracting specifications from them.

This commit fixes the problem by longer making considering cached specs
the default and only enable them when a resolve is actually needed.

https://github.com/rubygems/rubygems/commit/edeb2c42bf
---
 lib/bundler/definition.rb            |  2 ++
 lib/bundler/self_manager.rb          |  2 +-
 lib/bundler/source/rubygems.rb       |  3 +--
 lib/bundler/source_list.rb           |  8 ++++++--
 lib/bundler/spec_set.rb              |  1 -
 spec/bundler/commands/exec_spec.rb   |  4 ++--
 spec/bundler/commands/lock_spec.rb   |  2 +-
 spec/bundler/install/yanked_spec.rb  |  6 +++---
 spec/bundler/runtime/require_spec.rb | 24 ++++++++++++++++++++++++
 spec/bundler/runtime/setup_spec.rb   |  2 +-
 10 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb
index 5c9437a83c2a9c..6cf1f9a2556237 100644
--- a/lib/bundler/definition.rb
+++ b/lib/bundler/definition.rb
@@ -168,11 +168,13 @@ def resolve_only_locally!
     end
 
     def resolve_with_cache!
+      sources.local!
       sources.cached!
       resolve
     end
 
     def resolve_remotely!
+      sources.cached!
       sources.remote!
       resolve
     end
diff --git a/lib/bundler/self_manager.rb b/lib/bundler/self_manager.rb
index bfd000b1a01da2..5accda4bcbaccc 100644
--- a/lib/bundler/self_manager.rb
+++ b/lib/bundler/self_manager.rb
@@ -113,7 +113,7 @@ def resolve_update_version_from(target)
     end
 
     def local_specs
-      @local_specs ||= Bundler::Source::Rubygems.new("allow_local" => true, "allow_cached" => true).specs.select {|spec| spec.name == "bundler" }
+      @local_specs ||= Bundler::Source::Rubygems.new("allow_local" => true).specs.select {|spec| spec.name == "bundler" }
     end
 
     def remote_specs
diff --git a/lib/bundler/source/rubygems.rb b/lib/bundler/source/rubygems.rb
index 2e76becb84915a..553039ea17980f 100644
--- a/lib/bundler/source/rubygems.rb
+++ b/lib/bundler/source/rubygems.rb
@@ -17,7 +17,7 @@ def initialize(options = {})
         @remotes = []
         @dependency_names = []
         @allow_remote = false
-        @allow_cached = options["allow_cached"] || false
+        @allow_cached = false
         @allow_local = options["allow_local"] || false
         @checksum_store = Checksum::Store.new
 
@@ -53,7 +53,6 @@ def cached!
         return if @allow_cached
 
         @specs = nil
-        @allow_local = true
         @allow_cached = true
       end
 
diff --git a/lib/bundler/source_list.rb b/lib/bundler/source_list.rb
index ece2177d49b6eb..5f9dd68f175735 100644
--- a/lib/bundler/source_list.rb
+++ b/lib/bundler/source_list.rb
@@ -9,7 +9,7 @@ class SourceList
       :metadata_source
 
     def global_rubygems_source
-      @global_rubygems_source ||= rubygems_aggregate_class.new("allow_local" => true, "allow_cached" => true)
+      @global_rubygems_source ||= rubygems_aggregate_class.new("allow_local" => true)
     end
 
     def initialize
@@ -145,6 +145,10 @@ def local_only!
       all_sources.each(&:local_only!)
     end
 
+    def local!
+      all_sources.each(&:local!)
+    end
+
     def cached!
       all_sources.each(&:cached!)
     end
@@ -185,7 +189,7 @@ def global_replacement_source(replacement_sources)
       replacement_source = replace_rubygems_source(replacement_sources, global_rubygems_source)
       return global_rubygems_source unless replacement_source
 
-      replacement_source.cached!
+      replacement_source.local!
       replacement_source
     end
 
diff --git a/lib/bundler/spec_set.rb b/lib/bundler/spec_set.rb
index 8e1130e40ed81f..2933d284500668 100644
--- a/lib/bundler/spec_set.rb
+++ b/lib/bundler/spec_set.rb
@@ -129,7 +129,6 @@ def materialize(deps)
     def materialized_for_all_platforms
       @specs.map do |s|
         next s unless s.is_a?(LazySpecification)
-        s.source.cached!
         s.source.remote!
         spec = s.materialize_for_installation
         raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
diff --git a/spec/bundler/commands/exec_spec.rb b/spec/bundler/commands/exec_spec.rb
index d59b690d2f4ef4..9f5f12739aeaa0 100644
--- a/spec/bundler/commands/exec_spec.rb
+++ b/spec/bundler/commands/exec_spec.rb
@@ -885,7 +885,7 @@ def bin_path(a,b,c)
       let(:exit_code) { Bundler::GemNotFound.new.status_code }
       let(:expected) { "" }
       let(:expected_err) { <<-EOS.strip }
-Could not find gem 'rack (= 2)' in cached gems or installed locally.
+Could not find gem 'rack (= 2)' in locally installed gems.
 
 The source contains the following gems matching 'rack':
   * rack-0.9.1
@@ -915,7 +915,7 @@ def bin_path(a,b,c)
       let(:exit_code) { Bundler::GemNotFound.new.status_code }
       let(:expected) { "" }
       let(:expected_err) { <<-EOS.strip }
-Could not find gem 'rack (= 2)' in cached gems or installed locally.
+Could not find gem 'rack (= 2)' in locally installed gems.
 
 The source contains the following gems matching 'rack':
   * rack-1.0.0
diff --git a/spec/bundler/commands/lock_spec.rb b/spec/bundler/commands/lock_spec.rb
index c6bb0f58afe074..abf749eb902d95 100644
--- a/spec/bundler/commands/lock_spec.rb
+++ b/spec/bundler/commands/lock_spec.rb
@@ -138,7 +138,7 @@
   it "does not fetch remote specs when using the --local option" do
     bundle "lock --update --local", raise_on_error: false
 
-    expect(err).to match(/cached gems or installed locally/)
+    expect(err).to match(/locally installed gems/)
   end
 
   it "does not fetch remote checksums with --local" do
diff --git a/spec/bundler/install/yanked_spec.rb b/spec/bundler/install/yanked_spec.rb
index 7408c243272512..5aeabd2f236a71 100644
--- a/spec/bundler/install/yanked_spec.rb
+++ b/spec/bundler/install/yanked_spec.rb
@@ -188,7 +188,7 @@
 
     bundle :list, raise_on_error: false
 
-    expect(err).to include("Could not find rack-0.9.1 in cached gems or installed locally")
+    expect(err).to include("Could not find rack-0.9.1 in locally installed gems")
     expect(err).to_not include("Your bundle is locked to rack (0.9.1) from")
     expect(err).to_not include("If you haven't changed sources, that means the author of rack (0.9.1) has removed it.")
     expect(err).to_not include("You'll need to update your bundle to a different version of rack (0.9.1) that hasn't been removed in order to install.")
@@ -197,7 +197,7 @@
     lockfile lockfile.gsub(/PLATFORMS\n  #{lockfile_platforms}/m, "PLATFORMS\n  #{lockfile_platforms("ruby")}")
 
     bundle :list, raise_on_error: false
-    expect(err).to include("Could not find rack-0.9.1 in cached gems or installed locally")
+    expect(err).to include("Could not find rack-0.9.1 in locally installed gems")
   end
 
   it "does not suggest the author has yanked the gem when using more than one gem, but shows all gems that couldn't be found in the source" do
@@ -224,7 +224,7 @@
 
     bundle :list, raise_on_error: false
 
-    expect(err).to include("Could not find rack-0.9.1, rack_middleware-1.0 in cached gems or installed locally")
+    expect(err).to include("Could not find rack-0.9.1, rack_middleware-1.0 in locally installed gems")
     expect(err).to include("Install missing gems with `bundle install`.")
     expect(err).to_not include("Your bundle is locked to rack (0.9.1) from")
     expect(err).to_not include("If you haven't changed sources, that means the author of rack (0.9.1) has removed it.")
diff --git a/spec/bundler/runtime/require_spec.rb b/spec/bundler/runtime/require_spec.rb
index 76271a5593b038..e630e902c9de60 100644
--- a/spec/bundler/runtime/require_spec.rb
+++ b/spec/bundler/runtime/require_spec.rb
@@ -430,6 +430,30 @@ def self.two
 
     expect(out).to eq("WIN")
   end
+
+  it "does not extract gemspecs from application cache packages" do
+    gemfile <<-G
+      source "#{file_uri_for(gem_repo1)}"
+      gem "rack"
+    G
+
+    bundle :cache
+
+    path = cached_gem("rack-1.0.0")
+
+    run <<-R
+      File.open("#{path}", "w") do |f|
+        f.write "broken package"
+      end
+    R
+
+    run <<-R
+      Bundler.require
+      puts "WIN"
+    R
+
+    expect(out).to eq("WIN")
+  end
 end
 
 RSpec.describe "Bundler.require with platform specific dependencies" do
diff --git a/spec/bundler/runtime/setup_spec.rb b/spec/bundler/runtime/setup_spec.rb
index 2d78825de46dfb..8b8988063cf2f7 100644
--- a/spec/bundler/runtime/setup_spec.rb
+++ b/spec/bundler/runtime/setup_spec.rb
@@ -767,7 +767,7 @@ def clean_load_path(lp)
     expect(err).to be_empty
   end
 
-  it "can require rubygems without warnings, when using a local cache", rubygems: ">= 3.5.10" do
+  it "can require rubygems without warnings, when using a local cache" do
     install_gemfile <<-G
       source "#{file_uri_for(gem_repo1)}"
       gem "rack"

From eef125fd09f71185407ba7596aeb3811437a9b54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 12:58:17 +0200
Subject: [PATCH 175/242] [rubygems/rubygems] Fix error messages to not mention
 cached gems when they were not used

https://github.com/rubygems/rubygems/commit/5ce9a7ff17
---
 lib/bundler/source/rubygems.rb                         | 2 ++
 spec/bundler/commands/lock_spec.rb                     | 4 ++--
 spec/bundler/commands/post_bundle_message_spec.rb      | 2 +-
 spec/bundler/install/gemfile/git_spec.rb               | 2 +-
 spec/bundler/install/gemfile/sources_spec.rb           | 4 ++--
 spec/bundler/install/gemfile/specific_platform_spec.rb | 6 +++---
 spec/bundler/install/gems/flex_spec.rb                 | 2 +-
 spec/bundler/install/gems/resolving_spec.rb            | 4 ++--
 8 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/lib/bundler/source/rubygems.rb b/lib/bundler/source/rubygems.rb
index 553039ea17980f..3ac1bd4ff82808 100644
--- a/lib/bundler/source/rubygems.rb
+++ b/lib/bundler/source/rubygems.rb
@@ -50,6 +50,8 @@ def remote!
       end
 
       def cached!
+        return unless File.exist?(cache_path)
+
         return if @allow_cached
 
         @specs = nil
diff --git a/spec/bundler/commands/lock_spec.rb b/spec/bundler/commands/lock_spec.rb
index abf749eb902d95..b0d6fa9134026c 100644
--- a/spec/bundler/commands/lock_spec.rb
+++ b/spec/bundler/commands/lock_spec.rb
@@ -1349,7 +1349,7 @@
       Because rails >= 7.0.4 depends on railties = 7.0.4
         and rails < 7.0.4 depends on railties = 7.0.3.1,
         railties = 7.0.3.1 OR = 7.0.4 is required.
-      So, because railties = 7.0.3.1 OR = 7.0.4 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally,
+      So, because railties = 7.0.3.1 OR = 7.0.4 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally,
         version solving has failed.
     ERR
   end
@@ -1460,7 +1460,7 @@
       Thus, rails >= 7.0.2.3, < 7.0.4 cannot be used.
       And because rails >= 7.0.4 depends on activemodel = 7.0.4,
         rails >= 7.0.2.3 requires activemodel = 7.0.4.
-      So, because activemodel = 7.0.4 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally
+      So, because activemodel = 7.0.4 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally
         and Gemfile depends on rails >= 7.0.2.3,
         version solving has failed.
     ERR
diff --git a/spec/bundler/commands/post_bundle_message_spec.rb b/spec/bundler/commands/post_bundle_message_spec.rb
index 07fd5a79e97d4d..3c7fd3486de8b9 100644
--- a/spec/bundler/commands/post_bundle_message_spec.rb
+++ b/spec/bundler/commands/post_bundle_message_spec.rb
@@ -120,7 +120,7 @@
           gem "not-a-gem", :group => :development
         G
         expect(err).to include <<-EOS.strip
-Could not find gem 'not-a-gem' in rubygems repository #{file_uri_for(gem_repo1)}/, cached gems or installed locally.
+Could not find gem 'not-a-gem' in rubygems repository #{file_uri_for(gem_repo1)}/ or installed locally.
         EOS
       end
 
diff --git a/spec/bundler/install/gemfile/git_spec.rb b/spec/bundler/install/gemfile/git_spec.rb
index 45ee7b44d111e3..24cf30eadbe2ec 100644
--- a/spec/bundler/install/gemfile/git_spec.rb
+++ b/spec/bundler/install/gemfile/git_spec.rb
@@ -929,7 +929,7 @@
         gem "has_submodule"
       end
     G
-    expect(err).to match(%r{submodule >= 0 could not be found in rubygems repository #{file_uri_for(gem_repo1)}/, cached gems or installed locally})
+    expect(err).to match(%r{submodule >= 0 could not be found in rubygems repository #{file_uri_for(gem_repo1)}/ or installed locally})
 
     expect(the_bundle).not_to include_gems "has_submodule 1.0"
   end
diff --git a/spec/bundler/install/gemfile/sources_spec.rb b/spec/bundler/install/gemfile/sources_spec.rb
index a5ba76f4d9e26e..daee8a27443158 100644
--- a/spec/bundler/install/gemfile/sources_spec.rb
+++ b/spec/bundler/install/gemfile/sources_spec.rb
@@ -520,7 +520,7 @@
 
       it "fails" do
         bundle :install, artifice: "compact_index", raise_on_error: false
-        expect(err).to include("Could not find gem 'private_gem_1' in rubygems repository https://gem.repo2/, cached gems or installed locally.")
+        expect(err).to include("Could not find gem 'private_gem_1' in rubygems repository https://gem.repo2/ or installed locally.")
       end
     end
 
@@ -611,7 +611,7 @@
             Could not find compatible versions
 
             Because every version of depends_on_rack depends on rack >= 0
-              and rack >= 0 could not be found in rubygems repository https://gem.repo2/, cached gems or installed locally,
+              and rack >= 0 could not be found in rubygems repository https://gem.repo2/ or installed locally,
               depends_on_rack cannot be used.
             So, because Gemfile depends on depends_on_rack >= 0,
               version solving has failed.
diff --git a/spec/bundler/install/gemfile/specific_platform_spec.rb b/spec/bundler/install/gemfile/specific_platform_spec.rb
index 5f1b034bfc0de1..1a33053dc6e258 100644
--- a/spec/bundler/install/gemfile/specific_platform_spec.rb
+++ b/spec/bundler/install/gemfile/specific_platform_spec.rb
@@ -395,7 +395,7 @@
     G
 
     error_message = <<~ERROR.strip
-      Could not find gem 'sorbet-static (= 0.5.6433)' with platform 'arm64-darwin-21' in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally.
+      Could not find gem 'sorbet-static (= 0.5.6433)' with platform 'arm64-darwin-21' in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally.
 
       The source contains the following gems matching 'sorbet-static (= 0.5.6433)':
         * sorbet-static-0.5.6433-universal-darwin-20
@@ -434,7 +434,7 @@
       Could not find compatible versions
 
       Because every version of sorbet depends on sorbet-static = 0.5.6433
-        and sorbet-static = 0.5.6433 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally for any resolution platforms (arm64-darwin-21),
+        and sorbet-static = 0.5.6433 could not be found in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally for any resolution platforms (arm64-darwin-21),
         sorbet cannot be used.
       So, because Gemfile depends on sorbet = 0.5.6433,
         version solving has failed.
@@ -473,7 +473,7 @@
     bundle "lock", raise_on_error: false, env: { "BUNDLE_FORCE_RUBY_PLATFORM" => "true" }
 
     expect(err).to include <<~ERROR.rstrip
-      Could not find gem 'sorbet-static (= 0.5.9889)' with platform 'ruby' in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally.
+      Could not find gem 'sorbet-static (= 0.5.9889)' with platform 'ruby' in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally.
 
       The source contains the following gems matching 'sorbet-static (= 0.5.9889)':
         * sorbet-static-0.5.9889-#{Gem::Platform.local}
diff --git a/spec/bundler/install/gems/flex_spec.rb b/spec/bundler/install/gems/flex_spec.rb
index 8ef3984975458b..5e0c88fc9510c3 100644
--- a/spec/bundler/install/gems/flex_spec.rb
+++ b/spec/bundler/install/gems/flex_spec.rb
@@ -197,7 +197,7 @@
         Could not find compatible versions
 
         Because rack-obama >= 2.0 depends on rack = 1.2
-          and rack = 1.2 could not be found in rubygems repository #{file_uri_for(gem_repo2)}/, cached gems or installed locally,
+          and rack = 1.2 could not be found in rubygems repository #{file_uri_for(gem_repo2)}/ or installed locally,
           rack-obama >= 2.0 cannot be used.
         So, because Gemfile depends on rack-obama = 2.0,
           version solving has failed.
diff --git a/spec/bundler/install/gems/resolving_spec.rb b/spec/bundler/install/gems/resolving_spec.rb
index c5f9c4a3d3e456..b54674898da5b7 100644
--- a/spec/bundler/install/gems/resolving_spec.rb
+++ b/spec/bundler/install/gems/resolving_spec.rb
@@ -434,7 +434,7 @@
           end
 
           nice_error = <<~E.strip
-            Could not find gems matching 'sorbet-static (= 0.5.10554)' valid for all resolution platforms (arm64-darwin-21, aarch64-linux) in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally.
+            Could not find gems matching 'sorbet-static (= 0.5.10554)' valid for all resolution platforms (arm64-darwin-21, aarch64-linux) in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally.
 
             The source contains the following gems matching 'sorbet-static (= 0.5.10554)':
               * sorbet-static-0.5.10554-universal-darwin-21
@@ -490,7 +490,7 @@
 
         it "raises a proper error" do
           nice_error = <<~E.strip
-            Could not find gems matching 'sorbet-static' valid for all resolution platforms (arm-linux, x86_64-linux) in rubygems repository #{file_uri_for(gem_repo4)}/, cached gems or installed locally.
+            Could not find gems matching 'sorbet-static' valid for all resolution platforms (arm-linux, x86_64-linux) in rubygems repository #{file_uri_for(gem_repo4)}/ or installed locally.
 
             The source contains the following gems matching 'sorbet-static':
               * sorbet-static-0.5.10696-x86_64-linux

From 6a7e4c40e13b020bb210f5b5c5c7f34dce18775d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Wed, 22 May 2024 19:21:52 +0200
Subject: [PATCH 176/242] [rubygems/rubygems] Neither `--force` flag or inline
 mode should mandate a remote resolution

https://github.com/rubygems/rubygems/commit/50dd93e217
---
 lib/bundler/installer.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/bundler/installer.rb b/lib/bundler/installer.rb
index 1c5ed7c048a637..256f0be3487cba 100644
--- a/lib/bundler/installer.rb
+++ b/lib/bundler/installer.rb
@@ -237,7 +237,7 @@ def install_in_parallel(size, standalone, force = false)
     def resolve_if_needed(options)
       @definition.prefer_local! if options["prefer-local"]
 
-      if options["local"] || (!options["force"] && !Bundler.settings[:inline] && @definition.no_resolve_needed? && !@definition.missing_specs?)
+      if options["local"] || (@definition.no_resolve_needed? && !@definition.missing_specs?)
         @definition.resolve_with_cache!
         false
       else

From 180ae00989d726df5be9d6203f886e6ff5f9ec8d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Thu, 23 May 2024 15:38:08 +0200
Subject: [PATCH 177/242] [rubygems/rubygems] Rework `bundle gem` specs so that
 they work on Windows

Most of the commands run by these specs actually prompt for user input
but for some reason `Open3` outside of Windows ignores that and goes on
with no user input. Windows does not like this.

This commit refactors these specs so that:

* They don't prompt for user input when not necessary.
* They pass proper user input when necessary.

As long as no user input is needed, most specs pass, so it allows to
remove the `:readline` tag from most of them.

https://github.com/rubygems/rubygems/commit/3dfabcdae4
---
 spec/bundler/commands/newgem_spec.rb         | 131 +++++++++++--------
 spec/bundler/other/major_deprecation_spec.rb |   7 +-
 spec/bundler/support/helpers.rb              |  16 ++-
 3 files changed, 96 insertions(+), 58 deletions(-)

diff --git a/spec/bundler/commands/newgem_spec.rb b/spec/bundler/commands/newgem_spec.rb
index 199340b1314ccd..53d0f9d6eb6f53 100644
--- a/spec/bundler/commands/newgem_spec.rb
+++ b/spec/bundler/commands/newgem_spec.rb
@@ -36,22 +36,25 @@ def bundle_exec_standardrb
     sys_exec("git config --global user.name 'Bundler User'")
     sys_exec("git config --global user.email user@example.com")
     sys_exec("git config --global github.user bundleuser")
+
+    global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false", "BUNDLE_GEM__LINTER" => "false",
+                  "BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__CHANGELOG" => "false"
   end
 
   describe "git repo initialization" do
-    it "generates a gem skeleton with a .git folder", :readline do
+    it "generates a gem skeleton with a .git folder" do
       bundle "gem #{gem_name}"
       gem_skeleton_assertions
       expect(bundled_app("#{gem_name}/.git")).to exist
     end
 
-    it "generates a gem skeleton with a .git folder when passing --git", :readline do
+    it "generates a gem skeleton with a .git folder when passing --git" do
       bundle "gem #{gem_name} --git"
       gem_skeleton_assertions
       expect(bundled_app("#{gem_name}/.git")).to exist
     end
 
-    it "generates a gem skeleton without a .git folder when passing --no-git", :readline do
+    it "generates a gem skeleton without a .git folder when passing --no-git" do
       bundle "gem #{gem_name} --no-git"
       gem_skeleton_assertions
       expect(bundled_app("#{gem_name}/.git")).not_to exist
@@ -62,7 +65,9 @@ def bundle_exec_standardrb
         Dir.mkdir(bundled_app("path with spaces"))
       end
 
-      it "properly initializes git repo", :readline do
+      it "properly initializes git repo" do
+        skip "path with spaces needs special handling on Windows" if Gem.win_platform?
+
         bundle "gem #{gem_name}", dir: bundled_app("path with spaces")
         expect(bundled_app("path with spaces/#{gem_name}/.git")).to exist
       end
@@ -131,7 +136,7 @@ def bundle_exec_standardrb
     before do
       bundle "gem #{gem_name} --changelog"
     end
-    it "generates a gem skeleton with a CHANGELOG", :readline do
+    it "generates a gem skeleton with a CHANGELOG" do
       gem_skeleton_assertions
       expect(bundled_app("#{gem_name}/CHANGELOG.md")).to exist
     end
@@ -141,7 +146,7 @@ def bundle_exec_standardrb
     before do
       bundle "gem #{gem_name} --no-changelog"
     end
-    it "generates a gem skeleton without a CHANGELOG", :readline do
+    it "generates a gem skeleton without a CHANGELOG" do
       gem_skeleton_assertions
       expect(bundled_app("#{gem_name}/CHANGELOG.md")).to_not exist
     end
@@ -150,6 +155,7 @@ def bundle_exec_standardrb
   shared_examples_for "--rubocop flag" do
     context "is deprecated", bundler: "< 3" do
       before do
+        global_config "BUNDLE_GEM__LINTER" => nil
         bundle "gem #{gem_name} --rubocop"
       end
 
@@ -303,49 +309,49 @@ def bundle_exec_standardrb
     end
   end
 
-  it "has no rubocop offenses when using --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --linter=rubocop"
     bundle_exec_rubocop
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=c and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=c and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --ext=c --linter=rubocop"
     bundle_exec_rubocop
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=c, --test=minitest, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=c, --test=minitest, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --ext=c --test=minitest --linter=rubocop"
     bundle_exec_rubocop
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=c, --test=rspec, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=c, --test=rspec, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --ext=c --test=rspec --linter=rubocop"
     bundle_exec_rubocop
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=c, --test=test-unit, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=c, --test=test-unit, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --ext=c --test=test-unit --linter=rubocop"
     bundle_exec_rubocop
     expect(last_command).to be_success
   end
 
-  it "has no standard offenses when using --linter=standard flag", :readline do
+  it "has no standard offenses when using --linter=standard flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     bundle "gem #{gem_name} --linter=standard"
     bundle_exec_standardrb
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=rust and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=rust and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     skip "RubyGems incompatible with Rust builder" if ::Gem::Version.new("3.3.11") > ::Gem.rubygems_version
 
@@ -354,7 +360,7 @@ def bundle_exec_standardrb
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=rust, --test=minitest, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=rust, --test=minitest, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     skip "RubyGems incompatible with Rust builder" if ::Gem::Version.new("3.3.11") > ::Gem.rubygems_version
 
@@ -363,7 +369,7 @@ def bundle_exec_standardrb
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=rust, --test=rspec, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=rust, --test=rspec, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     skip "RubyGems incompatible with Rust builder" if ::Gem::Version.new("3.3.11") > ::Gem.rubygems_version
 
@@ -372,7 +378,7 @@ def bundle_exec_standardrb
     expect(last_command).to be_success
   end
 
-  it "has no rubocop offenses when using --ext=rust, --test=test-unit, and --linter=rubocop flag", :readline do
+  it "has no rubocop offenses when using --ext=rust, --test=test-unit, and --linter=rubocop flag" do
     skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?
     skip "RubyGems incompatible with Rust builder" if ::Gem::Version.new("3.3.11") > ::Gem.rubygems_version
 
@@ -399,7 +405,7 @@ def bundle_exec_standardrb
     end
   end
 
-  context "README.md", :readline do
+  context "README.md" do
     context "git config github.user present" do
       before do
         bundle "gem #{gem_name}"
@@ -424,12 +430,12 @@ def bundle_exec_standardrb
     end
   end
 
-  it "creates a new git repository", :readline do
+  it "creates a new git repository" do
     bundle "gem #{gem_name}"
     expect(bundled_app("#{gem_name}/.git")).to exist
   end
 
-  context "when git is not available", :readline do
+  context "when git is not available" do
     # This spec cannot have `git` available in the test env
     before do
       load_paths = [lib_dir, spec_dir]
@@ -451,7 +457,7 @@ def bundle_exec_standardrb
     end
   end
 
-  it "generates a valid gemspec", :readline, :ruby_repo do
+  it "generates a valid gemspec", :ruby_repo do
     bundle "gem newgem --bin"
 
     prepare_gemspec(bundled_app("newgem", "newgem.gemspec"))
@@ -464,7 +470,7 @@ def bundle_exec_standardrb
     expect(last_command.stdboth).not_to include("ERROR")
   end
 
-  context "gem naming with relative paths", :readline do
+  context "gem naming with relative paths" do
     it "resolves ." do
       create_temporary_dir("tmp")
 
@@ -557,8 +563,12 @@ def create_temporary_dir(dir)
 
       expect(bundled_app("#{gem_name}/bin/setup")).to exist
       expect(bundled_app("#{gem_name}/bin/console")).to exist
-      expect(bundled_app("#{gem_name}/bin/setup")).to be_executable
-      expect(bundled_app("#{gem_name}/bin/console")).to be_executable
+
+      unless Gem.win_platform?
+        expect(bundled_app("#{gem_name}/bin/setup")).to be_executable
+        expect(bundled_app("#{gem_name}/bin/console")).to be_executable
+      end
+
       expect(bundled_app("#{gem_name}/bin/setup").read).to start_with("#!")
       expect(bundled_app("#{gem_name}/bin/console").read).to start_with("#!")
     end
@@ -870,7 +880,7 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.test set to rspec and --test with no arguments", :hint_text do
+    context "gem.test set to rspec and --test with no arguments" do
       before do
         bundle "config set gem.test rspec"
         bundle "gem #{gem_name} --test"
@@ -887,10 +897,12 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.test setting set to false and --test with no arguments", :hint_text do
+    context "gem.test setting set to false and --test with no arguments", :readline do
       before do
         bundle "config set gem.test false"
-        bundle "gem #{gem_name} --test"
+        bundle "gem #{gem_name} --test" do |input, _, _|
+          input.puts
+        end
       end
 
       it "asks to generate test files" do
@@ -904,9 +916,12 @@ def create_temporary_dir(dir)
       it_behaves_like "test framework is absent"
     end
 
-    context "gem.test setting not set and --test with no arguments", :hint_text do
+    context "gem.test setting not set and --test with no arguments", :readline do
       before do
-        bundle "gem #{gem_name} --test"
+        global_config "BUNDLE_GEM__TEST" => nil
+        bundle "gem #{gem_name} --test" do |input, _, _|
+          input.puts
+        end
       end
 
       it "asks to generate test files" do
@@ -1009,7 +1024,7 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.ci set to github and --ci with no arguments", :hint_text do
+    context "gem.ci set to github and --ci with no arguments" do
       before do
         bundle "config set gem.ci github"
         bundle "gem #{gem_name} --ci"
@@ -1024,10 +1039,12 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.ci setting set to false and --ci with no arguments", :hint_text do
+    context "gem.ci setting set to false and --ci with no arguments", :readline do
       before do
         bundle "config set gem.ci false"
-        bundle "gem #{gem_name} --ci"
+        bundle "gem #{gem_name} --ci" do |input, _, _|
+          input.puts "github"
+        end
       end
 
       it "asks to setup CI" do
@@ -1039,9 +1056,12 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.ci setting not set and --ci with no arguments", :hint_text do
+    context "gem.ci setting not set and --ci with no arguments", :readline do
       before do
-        bundle "gem #{gem_name} --ci"
+        global_config "BUNDLE_GEM__CI" => nil
+        bundle "gem #{gem_name} --ci" do |input, _, _|
+          input.puts "github"
+        end
       end
 
       it "asks to setup CI" do
@@ -1111,6 +1131,7 @@ def create_temporary_dir(dir)
 
     context "gem.rubocop setting set to true", bundler: "< 3" do
       before do
+        global_config "BUNDLE_GEM__LINTER" => nil
         bundle "config set gem.rubocop true"
         bundle "gem #{gem_name}"
       end
@@ -1130,7 +1151,7 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.linter set to rubocop and --linter with no arguments", :hint_text do
+    context "gem.linter set to rubocop and --linter with no arguments" do
       before do
         bundle "config set gem.linter rubocop"
         bundle "gem #{gem_name} --linter"
@@ -1145,10 +1166,12 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.linter setting set to false and --linter with no arguments", :hint_text do
+    context "gem.linter setting set to false and --linter with no arguments", :readline do
       before do
         bundle "config set gem.linter false"
-        bundle "gem #{gem_name} --linter"
+        bundle "gem #{gem_name} --linter" do |input, _, _|
+          input.puts "rubocop"
+        end
       end
 
       it "asks to setup a linter" do
@@ -1160,9 +1183,12 @@ def create_temporary_dir(dir)
       end
     end
 
-    context "gem.linter setting not set and --linter with no arguments", :hint_text do
+    context "gem.linter setting not set and --linter with no arguments", :readline do
       before do
-        bundle "gem #{gem_name} --linter"
+        global_config "BUNDLE_GEM__LINTER" => nil
+        bundle "gem #{gem_name} --linter" do |input, _, _|
+          input.puts "rubocop"
+        end
       end
 
       it "asks to setup a linter" do
@@ -1185,7 +1211,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "testing --mit and --coc options against bundle config settings", :readline do
+  context "testing --mit and --coc options against bundle config settings" do
     let(:gem_name) { "test-gem" }
 
     let(:require_path) { "test/gem" }
@@ -1288,7 +1314,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "testing --github-username option against git and bundle config settings", :readline do
+  context "testing --github-username option against git and bundle config settings" do
     context "without git config set" do
       before do
         sys_exec("git config --global --unset github.user")
@@ -1325,7 +1351,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "testing github_username bundle config against git config settings", :readline do
+  context "testing github_username bundle config against git config settings" do
     context "without git config set" do
       before do
         sys_exec("git config --global --unset github.user")
@@ -1339,7 +1365,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "gem naming with underscore", :readline do
+  context "gem naming with underscore" do
     let(:gem_name) { "test_gem" }
 
     let(:require_path) { "test_gem" }
@@ -1485,7 +1511,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "gem naming with dashed", :readline do
+  context "gem naming with dashed" do
     let(:gem_name) { "test-gem" }
 
     let(:require_path) { "test/gem" }
@@ -1506,7 +1532,7 @@ def create_temporary_dir(dir)
   end
 
   describe "uncommon gem names" do
-    it "can deal with two dashes", :readline do
+    it "can deal with two dashes" do
       bundle "gem a--a"
 
       expect(bundled_app("a--a/a--a.gemspec")).to exist
@@ -1536,7 +1562,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  describe "#ensure_safe_gem_name", :readline do
+  describe "#ensure_safe_gem_name" do
     before do
       bundle "gem #{subject}", raise_on_error: false
     end
@@ -1564,7 +1590,7 @@ def create_temporary_dir(dir)
 
   context "on first run", :readline do
     it "asks about test framework" do
-      global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__COC" => "false"
+      global_config "BUNDLE_GEM__TEST" => nil
 
       bundle "gem foobar" do |input, _, _|
         input.puts "rspec"
@@ -1587,7 +1613,7 @@ def create_temporary_dir(dir)
     end
 
     it "asks about CI service" do
-      global_config "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__COC" => "false", "BUNDLE_GEM__LINTER" => "false"
+      global_config "BUNDLE_GEM__CI" => nil
 
       bundle "gem foobar" do |input, _, _|
         input.puts "github"
@@ -1597,7 +1623,7 @@ def create_temporary_dir(dir)
     end
 
     it "asks about MIT license" do
-      global_config "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false", "BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__LINTER" => "false"
+      global_config "BUNDLE_GEM__MIT" => nil
 
       bundle "config list"
 
@@ -1609,7 +1635,7 @@ def create_temporary_dir(dir)
     end
 
     it "asks about CoC" do
-      global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__LINTER" => "false"
+      global_config "BUNDLE_GEM__COC" => nil
 
       bundle "gem foobar" do |input, _, _|
         input.puts "yes"
@@ -1619,8 +1645,7 @@ def create_temporary_dir(dir)
     end
 
     it "asks about CHANGELOG" do
-      global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__LINTER" => "false",
-                    "BUNDLE_GEM__COC" => "false"
+      global_config "BUNDLE_GEM__CHANGELOG" => nil
 
       bundle "gem foobar" do |input, _, _|
         input.puts "yes"
@@ -1630,7 +1655,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "on conflicts with a previously created file", :readline do
+  context "on conflicts with a previously created file" do
     it "should fail gracefully" do
       FileUtils.touch(bundled_app("conflict-foobar"))
       bundle "gem conflict-foobar", raise_on_error: false
@@ -1639,7 +1664,7 @@ def create_temporary_dir(dir)
     end
   end
 
-  context "on conflicts with a previously created directory", :readline do
+  context "on conflicts with a previously created directory" do
     it "should succeed" do
       FileUtils.mkdir_p(bundled_app("conflict-foobar/Gemfile"))
       bundle "gem conflict-foobar"
diff --git a/spec/bundler/other/major_deprecation_spec.rb b/spec/bundler/other/major_deprecation_spec.rb
index 939b68a0bbf6c9..e7577d38b49074 100644
--- a/spec/bundler/other/major_deprecation_spec.rb
+++ b/spec/bundler/other/major_deprecation_spec.rb
@@ -618,7 +618,12 @@
     pending "fails with a helpful message", bundler: "3"
   end
 
-  describe "deprecating rubocop", :readline do
+  describe "deprecating rubocop" do
+    before do
+      global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false",
+                    "BUNDLE_GEM__CI" => "false", "BUNDLE_GEM__CHANGELOG" => "false"
+    end
+
     context "bundle gem --rubocop" do
       before do
         bundle "gem my_new_gem --rubocop", raise_on_error: false
diff --git a/spec/bundler/support/helpers.rb b/spec/bundler/support/helpers.rb
index 1ad9cc78ca19cc..dbb8b8152b5d2d 100644
--- a/spec/bundler/support/helpers.rb
+++ b/spec/bundler/support/helpers.rb
@@ -226,12 +226,20 @@ def all_commands_output
     end
 
     def config(config = nil, path = bundled_app(".bundle/config"))
-      return Psych.load_file(path) unless config
+      current = File.exist?(path) ? Psych.load_file(path) : {}
+      return current unless config
+
+      current = {} if current.empty?
+
       FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, "w") do |f|
-        f.puts config.to_yaml
+
+      new_config = current.merge(config).compact
+
+      File.open(path, "w+") do |f|
+        f.puts new_config.to_yaml
       end
-      config
+
+      new_config
     end
 
     def global_config(config = nil)

From 7021e15652194316df25830c5370611a16b8829b Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 15:07:47 -0400
Subject: [PATCH 178/242] [ruby/prism] Update duplicated when error message

https://github.com/ruby/prism/commit/54316fd8a0
---
 prism/prism.c                        | 13 +++++++++----
 prism/static_literals.c              | 27 +++++++++++++++++++--------
 prism/static_literals.h              |  3 ++-
 prism/templates/src/diagnostic.c.erb |  2 +-
 test/prism/warnings_test.rb          |  2 +-
 5 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 6d0dd6b66f4e94..385c64595b309b 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -13737,7 +13737,7 @@ parse_statements(pm_parser_t *parser, pm_context_t context) {
  */
 static void
 pm_hash_key_static_literals_add(pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node) {
-    const pm_node_t *duplicated = pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node);
+    const pm_node_t *duplicated = pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node, true);
 
     if (duplicated != NULL) {
         pm_buffer_t buffer = { 0 };
@@ -13763,13 +13763,16 @@ pm_hash_key_static_literals_add(pm_parser_t *parser, pm_static_literals_t *liter
  */
 static void
 pm_when_clause_static_literals_add(pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node) {
-    if (pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node) != NULL) {
+    pm_node_t *previous;
+
+    if ((previous = pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node, false)) != NULL) {
         pm_diagnostic_list_append_format(
             &parser->warning_list,
             node->location.start,
             node->location.end,
             PM_WARN_DUPLICATED_WHEN_CLAUSE,
-            pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line
+            pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line,
+            pm_newline_list_line_column(&parser->newline_list, previous->location.start, parser->start_line).line
         );
     }
 }
@@ -16370,7 +16373,7 @@ parse_pattern_hash_implicit_value(pm_parser_t *parser, pm_constant_id_list_t *ca
  */
 static void
 parse_pattern_hash_key(pm_parser_t *parser, pm_static_literals_t *keys, pm_node_t *node) {
-    if (pm_static_literals_add(&parser->newline_list, parser->start_line, keys, node) != NULL) {
+    if (pm_static_literals_add(&parser->newline_list, parser->start_line, keys, node, true) != NULL) {
         pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_KEY_DUPLICATE);
     }
 }
@@ -18132,6 +18135,8 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                             // as frozen because when clause strings are frozen.
                             if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
                                 pm_node_flag_set(condition, PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL);
+                            } else if (PM_NODE_TYPE_P(condition, PM_SOURCE_FILE_NODE)) {
+                                pm_node_flag_set(condition, PM_NODE_FLAG_STATIC_LITERAL);
                             }
 
                             pm_when_clause_static_literals_add(parser, &literals, condition);
diff --git a/prism/static_literals.c b/prism/static_literals.c
index 754a2d26b4a9e7..3b0cb13bf50173 100644
--- a/prism/static_literals.c
+++ b/prism/static_literals.c
@@ -154,7 +154,7 @@ node_hash(const pm_static_literals_metadata_t *metadata, const pm_node_t *node)
  * and must be able to compare all node types that will be stored in this hash.
  */
 static pm_node_t *
-pm_node_hash_insert(pm_node_hash_t *hash, const pm_static_literals_metadata_t *metadata, pm_node_t *node, int (*compare)(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right)) {
+pm_node_hash_insert(pm_node_hash_t *hash, const pm_static_literals_metadata_t *metadata, pm_node_t *node, bool replace, int (*compare)(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right)) {
     // If we are out of space, we need to resize the hash. This will cause all
     // of the nodes to be rehashed and reinserted into the new hash.
     if (hash->size * 2 >= hash->capacity) {
@@ -202,9 +202,14 @@ pm_node_hash_insert(pm_node_hash_t *hash, const pm_static_literals_metadata_t *m
     // already in the hash. Otherwise, we can just increment the size and insert
     // the new node.
     pm_node_t *result = hash->nodes[index];
-    if (result == NULL) hash->size++;
 
-    hash->nodes[index] = node;
+    if (result == NULL) {
+        hash->size++;
+        hash->nodes[index] = node;
+    } else if (replace) {
+        hash->nodes[index] = node;
+    }
+
     return result;
 }
 
@@ -348,7 +353,7 @@ pm_compare_regular_expression_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_liter
  * Add a node to the set of static literals.
  */
 pm_node_t *
-pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node) {
+pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node, bool replace) {
     switch (PM_NODE_TYPE(node)) {
         case PM_INTEGER_NODE:
         case PM_SOURCE_LINE_NODE:
@@ -360,6 +365,7 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_integer_nodes
             );
         case PM_FLOAT_NODE:
@@ -371,6 +377,7 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_float_nodes
             );
         case PM_RATIONAL_NODE:
@@ -383,6 +390,7 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_number_nodes
             );
         case PM_STRING_NODE:
@@ -395,6 +403,7 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_string_nodes
             );
         case PM_REGULAR_EXPRESSION_NODE:
@@ -406,6 +415,7 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_regular_expression_nodes
             );
         case PM_SYMBOL_NODE:
@@ -417,26 +427,27 @@ pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line
                     .encoding_name = NULL
                 },
                 node,
+                replace,
                 pm_compare_string_nodes
             );
         case PM_TRUE_NODE: {
             pm_node_t *duplicated = literals->true_node;
-            literals->true_node = node;
+            if ((duplicated == NULL) || replace) literals->true_node = node;
             return duplicated;
         }
         case PM_FALSE_NODE: {
             pm_node_t *duplicated = literals->false_node;
-            literals->false_node = node;
+            if ((duplicated == NULL) || replace) literals->false_node = node;
             return duplicated;
         }
         case PM_NIL_NODE: {
             pm_node_t *duplicated = literals->nil_node;
-            literals->nil_node = node;
+            if ((duplicated == NULL) || replace) literals->nil_node = node;
             return duplicated;
         }
         case PM_SOURCE_ENCODING_NODE: {
             pm_node_t *duplicated = literals->source_encoding_node;
-            literals->source_encoding_node = node;
+            if ((duplicated == NULL) || replace) literals->source_encoding_node = node;
             return duplicated;
         }
         default:
diff --git a/prism/static_literals.h b/prism/static_literals.h
index 72706054c13fec..9ef10afce0580e 100644
--- a/prism/static_literals.h
+++ b/prism/static_literals.h
@@ -95,9 +95,10 @@ typedef struct {
  * @param start_line The line number that the parser starts on.
  * @param literals The set of static literals to add the node to.
  * @param node The node to add to the set.
+ * @param replace Whether to replace the previous node if one already exists.
  * @return A pointer to the node that is being overwritten, if there is one.
  */
-pm_node_t * pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node);
+pm_node_t * pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node, bool replace);
 
 /**
  * Free the internal memory associated with the given static literals set.
diff --git a/prism/templates/src/diagnostic.c.erb b/prism/templates/src/diagnostic.c.erb
index 715cbd659813fe..22beae922e347a 100644
--- a/prism/templates/src/diagnostic.c.erb
+++ b/prism/templates/src/diagnostic.c.erb
@@ -368,7 +368,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_WARN_COMPARISON_AFTER_COMPARISON]       = { "comparison '%.*s' after comparison", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_DOT_DOT_DOT_EOL]                   = { "... at EOL, should be parenthesized?", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_DUPLICATED_HASH_KEY]               = { "key %.*s is duplicated and overwritten on line %" PRIi32, PM_WARNING_LEVEL_DEFAULT },
-    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "duplicated 'when' clause with line %" PRIi32 " is ignored", PM_WARNING_LEVEL_VERBOSE },
+    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "'when' clause on line %" PRIi32 " duplicates 'when' clause on line %" PRIi32 " and is ignored", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_EQUAL_IN_CONDITIONAL_3_3]          = { "found `= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_EQUAL_IN_CONDITIONAL]              = { "found '= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_END_IN_METHOD]                     = { "END in method; use at_exit", PM_WARNING_LEVEL_DEFAULT },
diff --git a/test/prism/warnings_test.rb b/test/prism/warnings_test.rb
index 3e26cd2227ded4..7ad704918a0f63 100644
--- a/test/prism/warnings_test.rb
+++ b/test/prism/warnings_test.rb
@@ -65,7 +65,7 @@ def test_duplicated_hash_key
     end
 
     def test_duplicated_when_clause
-      assert_warning("case 1; when 1, 1; end", "clause with line")
+      assert_warning("case 1; when 1, 1; end", "when' clause")
     end
 
     def test_float_out_of_range

From 47f0965269dae95c678b4276861cc389d277ce33 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Wed, 15 May 2024 15:17:18 -0400
Subject: [PATCH 179/242] Update duplicated when clause warning message

---
 parse.y                            |  4 +--
 spec/ruby/language/case_spec.rb    | 39 +++++++++++++++++++++---------
 test/.excludes-prism/TestSyntax.rb |  1 -
 test/ripper/test_parser_events.rb  |  4 +--
 test/ruby/test_syntax.rb           | 12 ++++-----
 5 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/parse.y b/parse.y
index a14f49a62e02d6..759e7415ac98f0 100644
--- a/parse.y
+++ b/parse.y
@@ -13334,8 +13334,8 @@ check_literal_when(struct parser_params *p, NODE *arg, const YYLTYPE *loc)
     else {
         st_data_t line;
         if (st_lookup(p->case_labels, (st_data_t)arg, &line)) {
-            rb_warning1("duplicated 'when' clause with line %d is ignored",
-                        WARN_I((int)line));
+            rb_warning2("'when' clause on line %d duplicates 'when' clause on line %d and is ignored",
+                        WARN_I((int)nd_line(arg)), WARN_I((int)line));
             return;
         }
     }
diff --git a/spec/ruby/language/case_spec.rb b/spec/ruby/language/case_spec.rb
index 3262f09dd590f5..d289eca0377b55 100644
--- a/spec/ruby/language/case_spec.rb
+++ b/spec/ruby/language/case_spec.rb
@@ -416,17 +416,34 @@ def test(v)
     self.test(true).should == true
   end
 
-  it "warns if there are identical when clauses" do
-    -> {
-      eval <<~RUBY
-        case 1
-        when 2
-          :foo
-        when 2
-          :bar
-        end
-      RUBY
-    }.should complain(/warning: duplicated .when' clause with line \d+ is ignored/, verbose: true)
+  ruby_version_is ""..."3.4" do
+    it "warns if there are identical when clauses" do
+      -> {
+        eval <<~RUBY
+          case 1
+          when 2
+            :foo
+          when 2
+            :bar
+          end
+        RUBY
+      }.should complain(/warning: duplicated .when' clause with line \d+ is ignored/, verbose: true)
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "warns if there are identical when clauses" do
+      -> {
+        eval <<~RUBY
+          case 1
+          when 2
+            :foo
+          when 2
+            :bar
+          end
+        RUBY
+      }.should complain(/warning: 'when' clause on line \d+ duplicates 'when' clause on line \d+ and is ignored/, verbose: true)
+    end
   end
 end
 
diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index ab672d19a6aef8..ed4ae4431885c8 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,4 +1,3 @@
 exclude(:test_dedented_heredoc_continued_line, "https://bugs.ruby-lang.org/issues/20503")
-exclude(:test_duplicated_when, "https://bugs.ruby-lang.org/issues/20401")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")
 exclude(:test_keyword_self_reference, "https://bugs.ruby-lang.org/issues/20478")
diff --git a/test/ripper/test_parser_events.rb b/test/ripper/test_parser_events.rb
index dc94da01eed701..a5c7401968cdb7 100644
--- a/test/ripper/test_parser_events.rb
+++ b/test/ripper/test_parser_events.rb
@@ -1694,8 +1694,8 @@ def test_warning_duplicated_when_clause
       else
       end
     STR
-    assert_match(/duplicated 'when' clause/, fmt)
-    assert_equal([3], args)
+    assert_match(/duplicates 'when' clause/, fmt)
+    assert_equal([4, 3], args)
   end
 
   def test_warn_duplicated_hash_keys
diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
index f4c9f064598f8f..8f94ec71fc1ecd 100644
--- a/test/ruby/test_syntax.rb
+++ b/test/ruby/test_syntax.rb
@@ -713,8 +713,8 @@ def test_duplicated_opt_kwrest
   end
 
   def test_duplicated_when
-    w = 'warning: duplicated \'when\' clause with line 3 is ignored'
-    assert_warning(/3: #{w}.+4: #{w}.+4: #{w}.+5: #{w}.+5: #{w}/m) {
+    w = ->(line) { "warning: 'when' clause on line #{line} duplicates 'when' clause on line 3 and is ignored" }
+    assert_warning(/#{w[3]}.+#{w[4]}.+#{w[4]}.+#{w[5]}.+#{w[5]}/m) {
       eval %q{
         case 1
         when 1, 1
@@ -723,7 +723,7 @@ def test_duplicated_when
         end
       }
     }
-    assert_warning(/#{w}/) {#/3: #{w}.+4: #{w}.+5: #{w}.+5: #{w}/m){
+    assert_warning(/#{w[3]}.+#{w[4]}.+#{w[5]}.+#{w[5]}/m) {
       a = a = 1
       eval %q{
         case 1
@@ -733,7 +733,7 @@ def test_duplicated_when
         end
       }
     }
-    assert_warning(/3: #{w}/m) {
+    assert_warning(/#{w[3]}/) {
       eval %q{
         case 1
         when __LINE__, __LINE__
@@ -742,7 +742,7 @@ def test_duplicated_when
         end
       }
     }
-    assert_warning(/3: #{w}/m) {
+    assert_warning(/#{w[3]}/) {
       eval %q{
         case 1
         when __FILE__, __FILE__
@@ -754,7 +754,7 @@ def test_duplicated_when
   end
 
   def test_duplicated_when_check_option
-    w = /duplicated \'when\' clause with line 3 is ignored/
+    w = /'when' clause on line 4 duplicates 'when' clause on line 3 and is ignored/
     assert_in_out_err(%[-wc], "#{<<~"begin;"}\n#{<<~'end;'}", ["Syntax OK"], w)
     begin;
       case 1

From ba336027beea3b76798a053cb3e7fd06ae1e4741 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 12:12:56 -0400
Subject: [PATCH 180/242] [PRISM] Move error formatting into Ruby

---
 prism_compile.c | 364 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 363 insertions(+), 1 deletion(-)

diff --git a/prism_compile.c b/prism_compile.c
index da7865fc8ca35c..dfe34c24e1c3d9 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -9159,6 +9159,368 @@ pm_parse_result_free(pm_parse_result_t *result)
     pm_options_free(&result->options);
 }
 
+/** An error that is going to be formatted into the output. */
+typedef struct {
+    /** A pointer to the diagnostic that was generated during parsing. */
+    pm_diagnostic_t *error;
+
+    /** The start line of the diagnostic message. */
+    int32_t line;
+
+    /** The column start of the diagnostic message. */
+    uint32_t column_start;
+
+    /** The column end of the diagnostic message. */
+    uint32_t column_end;
+} pm_parse_error_t;
+
+/** The format that will be used to format the errors into the output. */
+typedef struct {
+    /** The prefix that will be used for line numbers. */
+    const char *number_prefix;
+
+    /** The prefix that will be used for blank lines. */
+    const char *blank_prefix;
+
+    /** The divider that will be used between sections of source code. */
+    const char *divider;
+
+    /** The length of the blank prefix. */
+    size_t blank_prefix_length;
+
+    /** The length of the divider. */
+    size_t divider_length;
+} pm_parse_error_format_t;
+
+#define PM_COLOR_GRAY "\033[38;5;102m"
+#define PM_COLOR_RED "\033[1;31m"
+#define PM_COLOR_RESET "\033[m"
+#define PM_ERROR_TRUNCATE 30
+
+static inline pm_parse_error_t *
+pm_parse_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
+    pm_parse_error_t *errors = xcalloc(error_list->size, sizeof(pm_parse_error_t));
+    if (errors == NULL) return NULL;
+
+    int32_t start_line = parser->start_line;
+    for (pm_diagnostic_t *error = (pm_diagnostic_t *) error_list->head; error != NULL; error = (pm_diagnostic_t *) error->node.next) {
+        pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.start, start_line);
+        pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
+
+        // We're going to insert this error into the array in sorted order. We
+        // do this by finding the first error that has a line number greater
+        // than the current error and then inserting the current error before
+        // that one.
+        size_t index = 0;
+        while (
+            (index < error_list->size) &&
+            (errors[index].error != NULL) &&
+            (
+                (errors[index].line < start.line) ||
+                ((errors[index].line == start.line) && (errors[index].column_start < start.column))
+            )
+        ) index++;
+
+        // Now we're going to shift all of the errors after this one down one
+        // index to make room for the new error.
+        if (index + 1 < error_list->size) {
+            memmove(&errors[index + 1], &errors[index], sizeof(pm_parse_error_t) * (error_list->size - index - 1));
+        }
+
+        // Finally, we'll insert the error into the array.
+        uint32_t column_end;
+        if (start.line == end.line) {
+            column_end = end.column;
+        } else {
+            column_end = (uint32_t) (newline_list->offsets[start.line - start_line + 1] - newline_list->offsets[start.line - start_line] - 1);
+        }
+
+        // Ensure we have at least one column of error.
+        if (start.column == column_end) column_end++;
+
+        errors[index] = (pm_parse_error_t) {
+            .error = error,
+            .line = start.line,
+            .column_start = start.column,
+            .column_end = column_end
+        };
+    }
+
+    return errors;
+}
+
+static inline void
+pm_parse_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t *newline_list, const char *number_prefix, int32_t line, uint32_t column_start, uint32_t column_end, pm_buffer_t *buffer) {
+    int32_t line_delta = line - parser->start_line;
+    assert(line_delta >= 0);
+
+    size_t index = (size_t) line_delta;
+    assert(index < newline_list->size);
+
+    const uint8_t *start = &parser->start[newline_list->offsets[index]];
+    const uint8_t *end;
+
+    if (index >= newline_list->size - 1) {
+        end = parser->end;
+    } else {
+        end = &parser->start[newline_list->offsets[index + 1]];
+    }
+
+    pm_buffer_append_format(buffer, number_prefix, line);
+
+    // Here we determine if we should truncate the end of the line.
+    bool truncate_end = false;
+    if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
+        end = start + column_end + PM_ERROR_TRUNCATE;
+        truncate_end = true;
+    }
+
+    // Here we determine if we should truncate the start of the line.
+    if (column_start >= PM_ERROR_TRUNCATE) {
+        pm_buffer_append_string(buffer, "... ", 4);
+        start += column_start;
+    }
+
+    pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
+
+    if (truncate_end) {
+        pm_buffer_append_string(buffer, " ...\n", 5);
+    } else if (end == parser->end && end[-1] != '\n') {
+        pm_buffer_append_string(buffer, "\n", 1);
+    }
+}
+
+/**
+ * Format the errors on the parser into the given buffer.
+ */
+static void
+pm_parse_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, bool colorize, bool inline_messages) {
+    assert(error_list->size != 0);
+
+    // First, we're going to sort all of the errors by line number using an
+    // insertion sort into a newly allocated array.
+    const int32_t start_line = parser->start_line;
+    const pm_newline_list_t *newline_list = &parser->newline_list;
+
+    pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
+    if (errors == NULL) return;
+
+    // Now we're going to determine how we're going to format line numbers and
+    // blank lines based on the maximum number of digits in the line numbers
+    // that are going to be displaid.
+    pm_parse_error_format_t error_format;
+    int32_t first_line_number = errors[0].line;
+    int32_t last_line_number = errors[error_list->size - 1].line;
+
+    // If we have a maximum line number that is negative, then we're going to
+    // use the absolute value for comparison but multiple by 10 to additionally
+    // have a column for the negative sign.
+    if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
+    if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
+    int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
+
+    if (max_line_number < 10) {
+        if (colorize) {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = PM_COLOR_GRAY "%1" PRIi32 " | " PM_COLOR_RESET,
+                .blank_prefix = PM_COLOR_GRAY "  | " PM_COLOR_RESET,
+                .divider = PM_COLOR_GRAY "  ~~~~~" PM_COLOR_RESET "\n"
+            };
+        } else {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = "%1" PRIi32 " | ",
+                .blank_prefix = "  | ",
+                .divider = "  ~~~~~\n"
+            };
+        }
+    } else if (max_line_number < 100) {
+        if (colorize) {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = PM_COLOR_GRAY "%2" PRIi32 " | " PM_COLOR_RESET,
+                .blank_prefix = PM_COLOR_GRAY "   | " PM_COLOR_RESET,
+                .divider = PM_COLOR_GRAY "  ~~~~~~" PM_COLOR_RESET "\n"
+            };
+        } else {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = "%2" PRIi32 " | ",
+                .blank_prefix = "   | ",
+                .divider = "  ~~~~~~\n"
+            };
+        }
+    } else if (max_line_number < 1000) {
+        if (colorize) {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = PM_COLOR_GRAY "%3" PRIi32 " | " PM_COLOR_RESET,
+                .blank_prefix = PM_COLOR_GRAY "    | " PM_COLOR_RESET,
+                .divider = PM_COLOR_GRAY "  ~~~~~~~" PM_COLOR_RESET "\n"
+            };
+        } else {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = "%3" PRIi32 " | ",
+                .blank_prefix = "    | ",
+                .divider = "  ~~~~~~~\n"
+            };
+        }
+    } else if (max_line_number < 10000) {
+        if (colorize) {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = PM_COLOR_GRAY "%4" PRIi32 " | " PM_COLOR_RESET,
+                .blank_prefix = PM_COLOR_GRAY "     | " PM_COLOR_RESET,
+                .divider = PM_COLOR_GRAY "  ~~~~~~~~" PM_COLOR_RESET "\n"
+            };
+        } else {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = "%4" PRIi32 " | ",
+                .blank_prefix = "     | ",
+                .divider = "  ~~~~~~~~\n"
+            };
+        }
+    } else {
+        if (colorize) {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = PM_COLOR_GRAY "%5" PRIi32 " | " PM_COLOR_RESET,
+                .blank_prefix = PM_COLOR_GRAY "      | " PM_COLOR_RESET,
+                .divider = PM_COLOR_GRAY "  ~~~~~~~~" PM_COLOR_RESET "\n"
+            };
+        } else {
+            error_format = (pm_parse_error_format_t) {
+                .number_prefix = "%5" PRIi32 " | ",
+                .blank_prefix = "      | ",
+                .divider = "  ~~~~~~~~\n"
+            };
+        }
+    }
+
+    error_format.blank_prefix_length = strlen(error_format.blank_prefix);
+    error_format.divider_length = strlen(error_format.divider);
+
+    // Now we're going to iterate through every error in our error list and
+    // display it. While we're iterating, we will display some padding lines of
+    // the source before the error to give some context. We'll be careful not to
+    // display the same line twice in case the errors are close enough in the
+    // source.
+    int32_t last_line = parser->start_line - 1;
+    uint32_t last_column_start = 0;
+    const pm_encoding_t *encoding = parser->encoding;
+
+    for (size_t index = 0; index < error_list->size; index++) {
+        pm_parse_error_t *error = &errors[index];
+
+        // Here we determine how many lines of padding of the source to display,
+        // based on the difference from the last line that was displaid.
+        if (error->line - last_line > 1) {
+            if (error->line - last_line > 2) {
+                if ((index != 0) && (error->line - last_line > 3)) {
+                    pm_buffer_append_string(buffer, error_format.divider, error_format.divider_length);
+                }
+
+                pm_buffer_append_string(buffer, "  ", 2);
+                pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
+            }
+
+            pm_buffer_append_string(buffer, "  ", 2);
+            pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
+        }
+
+        // If this is the first error or we're on a new line, then we'll display
+        // the line that has the error in it.
+        if ((index == 0) || (error->line != last_line)) {
+            if (colorize) {
+                pm_buffer_append_string(buffer, PM_COLOR_RED "> " PM_COLOR_RESET, 12);
+            } else {
+                pm_buffer_append_string(buffer, "> ", 2);
+            }
+
+            last_column_start = error->column_start;
+
+            // Find the maximum column end of all the errors on this line.
+            uint32_t column_end = error->column_end;
+            for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
+                if (errors[next_index].line != error->line) break;
+                if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
+            }
+
+            pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
+        }
+
+        const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
+        if (start == parser->end) pm_buffer_append_byte(buffer, '\n');
+
+        // Now we'll display the actual error message. We'll do this by first
+        // putting the prefix to the line, then a bunch of blank spaces
+        // depending on the column, then as many carets as we need to display
+        // the width of the error, then the error message itself.
+        //
+        // Note that this doesn't take into account the width of the actual
+        // character when displaid in the terminal. For some east-asian
+        // languages or emoji, this means it can be thrown off pretty badly. We
+        // will need to solve this eventually.
+        pm_buffer_append_string(buffer, "  ", 2);
+        pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
+
+        size_t column = 0;
+        if (last_column_start >= PM_ERROR_TRUNCATE) {
+            pm_buffer_append_string(buffer, "    ", 4);
+            column = last_column_start;
+        }
+
+        while (column < error->column_start) {
+            pm_buffer_append_byte(buffer, ' ');
+
+            size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
+            column += (char_width == 0 ? 1 : char_width);
+        }
+
+        if (colorize) pm_buffer_append_string(buffer, PM_COLOR_RED, 7);
+        pm_buffer_append_byte(buffer, '^');
+
+        size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
+        column += (char_width == 0 ? 1 : char_width);
+
+        while (column < error->column_end) {
+            pm_buffer_append_byte(buffer, '~');
+
+            size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
+            column += (char_width == 0 ? 1 : char_width);
+        }
+
+        if (colorize) pm_buffer_append_string(buffer, PM_COLOR_RESET, 3);
+
+        if (inline_messages) {
+            pm_buffer_append_byte(buffer, ' ');
+            assert(error->error != NULL);
+
+            const char *message = error->error->message;
+            pm_buffer_append_string(buffer, message, strlen(message));
+        }
+
+        pm_buffer_append_byte(buffer, '\n');
+
+        // Here we determine how many lines of padding to display after the
+        // error, depending on where the next error is in source.
+        last_line = error->line;
+        int32_t next_line = (index == error_list->size - 1) ? (((int32_t) newline_list->size) + parser->start_line) : errors[index + 1].line;
+
+        if (next_line - last_line > 1) {
+            pm_buffer_append_string(buffer, "  ", 2);
+            pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
+        }
+
+        if (next_line - last_line > 1) {
+            pm_buffer_append_string(buffer, "  ", 2);
+            pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
+        }
+    }
+
+    // Finally, we'll free the array of errors that we allocated.
+    xfree(errors);
+}
+
+#undef PM_ERROR_TRUNCATE
+#undef PM_COLOR_GRAY
+#undef PM_COLOR_RED
+#undef PM_COLOR_RESET
+
 /**
  * Check if the given source slice is valid UTF-8. The location represents the
  * location of the error, but the slice of the source will include the content
@@ -9230,7 +9592,7 @@ pm_parse_process_error(const pm_parse_result_t *result)
                 pm_list_node_t *list_node = (pm_list_node_t *) error;
                 pm_list_t error_list = { .size = 1, .head = list_node, .tail = list_node };
 
-                pm_parser_errors_format(parser, &error_list, &buffer, rb_stderr_tty_p(), false);
+                pm_parse_errors_format(parser, &error_list, &buffer, rb_stderr_tty_p(), false);
             }
 
             VALUE value = rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));

From 47b723f8906ba24af13292c43e389b716e24cf17 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 13:05:35 -0400
Subject: [PATCH 181/242] [PRISM] Use only bundled error formatting

---
 prism_compile.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prism_compile.c b/prism_compile.c
index dfe34c24e1c3d9..ea4c4fa054dea7 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -9622,7 +9622,7 @@ pm_parse_process_error(const pm_parse_result_t *result)
     );
 
     if (valid_utf8) {
-        pm_parser_errors_format(parser, &parser->error_list, &buffer, rb_stderr_tty_p(), true);
+        pm_parse_errors_format(parser, &parser->error_list, &buffer, rb_stderr_tty_p(), true);
     }
     else {
         for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {

From 870350253e1df70f56d33107b9ed3b9ebaaccdec Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 11:22:29 -0400
Subject: [PATCH 182/242] [ruby/prism] Remove Debug::static_inspect

https://github.com/ruby/prism/commit/486c71c426
---
 prism/extension.c                 | 35 -------------------------------
 prism/static_literals.c           |  2 +-
 prism/static_literals.h           |  2 +-
 prism/util/pm_char.h              |  3 +--
 test/prism/static_inspect_test.rb |  5 ++---
 5 files changed, 5 insertions(+), 42 deletions(-)

diff --git a/prism/extension.c b/prism/extension.c
index 84872914c42fd6..9375273ac51431 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -1223,40 +1223,6 @@ format_errors(VALUE self, VALUE source, VALUE colorize) {
     return result;
 }
 
-/**
- * call-seq:
- *   Debug::static_inspect(source) -> String
- *
- * Inspect the node as it would be inspected by the warnings used in static
- * literal sets.
- */
-static VALUE
-static_inspect(int argc, VALUE *argv, VALUE self) {
-    pm_string_t input;
-    pm_options_t options = { 0 };
-    string_options(argc, argv, &input, &options);
-
-    pm_parser_t parser;
-    pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), &options);
-
-    pm_node_t *program = pm_parse(&parser);
-    pm_node_t *node = ((pm_program_node_t *) program)->statements->body.nodes[0];
-
-    pm_buffer_t buffer = { 0 };
-    pm_static_literal_inspect(&buffer, &parser.newline_list, parser.start_line, parser.encoding->name, node);
-
-    rb_encoding *encoding = rb_enc_find(parser.encoding->name);
-    VALUE result = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), encoding);
-
-    pm_buffer_free(&buffer);
-    pm_node_destroy(&parser, program);
-    pm_parser_free(&parser);
-    pm_string_free(&input);
-    pm_options_free(&options);
-
-    return result;
-}
-
 /**
  * call-seq: Debug::Encoding.all -> Array[Debug::Encoding]
  *
@@ -1414,7 +1380,6 @@ Init_prism(void) {
     rb_define_singleton_method(rb_cPrismDebug, "memsize", memsize, 1);
     rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
     rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
-    rb_define_singleton_method(rb_cPrismDebug, "static_inspect", static_inspect, -1);
 
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
     rb_define_singleton_method(rb_cPrismDebug, "inspect_node", inspect_node, 1);
diff --git a/prism/static_literals.c b/prism/static_literals.c
index 3b0cb13bf50173..b8604321c98a0e 100644
--- a/prism/static_literals.c
+++ b/prism/static_literals.c
@@ -603,7 +603,7 @@ pm_static_literal_inspect_node(pm_buffer_t *buffer, const pm_static_literals_met
 /**
  * Create a string-based representation of the given static literal.
  */
-PRISM_EXPORTED_FUNCTION void
+void
 pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node) {
     pm_static_literal_inspect_node(
         buffer,
diff --git a/prism/static_literals.h b/prism/static_literals.h
index 9ef10afce0580e..bd29761899c29c 100644
--- a/prism/static_literals.h
+++ b/prism/static_literals.h
@@ -116,6 +116,6 @@ void pm_static_literals_free(pm_static_literals_t *literals);
  * @param encoding_name The name of the encoding of the source being parsed.
  * @param node The node to create a string representation of.
  */
-PRISM_EXPORTED_FUNCTION void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node);
+void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node);
 
 #endif
diff --git a/prism/util/pm_char.h b/prism/util/pm_char.h
index 32f698a42b962d..deeafd632177da 100644
--- a/prism/util/pm_char.h
+++ b/prism/util/pm_char.h
@@ -34,8 +34,7 @@ size_t pm_strspn_whitespace(const uint8_t *string, ptrdiff_t length);
  * @return The number of characters at the start of the string that are
  *     whitespace.
  */
-size_t
-pm_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, pm_newline_list_t *newline_list);
+size_t pm_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, pm_newline_list_t *newline_list);
 
 /**
  * Returns the number of characters at the start of the string that are inline
diff --git a/test/prism/static_inspect_test.rb b/test/prism/static_inspect_test.rb
index 8df2fd241e0eb3..cc8ed28c950cbd 100644
--- a/test/prism/static_inspect_test.rb
+++ b/test/prism/static_inspect_test.rb
@@ -2,8 +2,6 @@
 
 require_relative "test_helper"
 
-return if Prism::BACKEND == :FFI
-
 module Prism
   class StaticInspectTest < TestCase
     def test_false
@@ -84,7 +82,8 @@ def test_true
     private
 
     def static_inspect(source, **options)
-      Debug.static_inspect(source, **options)
+      warnings = Prism.parse("{ #{source} => 1, #{source} => 1 }", **options).warnings
+      warnings.last.message[/^key (.+) is duplicated and overwritten on line \d/, 1]
     end
   end
 end

From b8681c2e3723939e0a43354671208c70960d3d02 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 11:33:59 -0400
Subject: [PATCH 183/242] [ruby/prism] Remove Debug::integer_parse

https://github.com/ruby/prism/commit/14e397598b
---
 prism/extension.c                | 30 ------------------------------
 prism/util/pm_integer.c          |  2 +-
 prism/util/pm_integer.h          |  2 +-
 test/prism/integer_parse_test.rb |  6 +-----
 4 files changed, 3 insertions(+), 37 deletions(-)

diff --git a/prism/extension.c b/prism/extension.c
index 9375273ac51431..e67ea9b9dc2a6f 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -1065,35 +1065,6 @@ named_captures(VALUE self, VALUE source) {
     return names;
 }
 
-/**
- * call-seq:
- *   Debug::integer_parse(source) -> [Integer, String]
- *
- * Parses the given source string and returns the integer it represents, as well
- * as a decimal string representation.
- */
-static VALUE
-integer_parse(VALUE self, VALUE source) {
-    const uint8_t *start = (const uint8_t *) RSTRING_PTR(source);
-    size_t length = RSTRING_LEN(source);
-
-    pm_integer_t integer = { 0 };
-    pm_integer_parse(&integer, PM_INTEGER_BASE_UNKNOWN, start, start + length);
-
-    pm_buffer_t buffer = { 0 };
-    pm_integer_string(&buffer, &integer);
-
-    VALUE string = rb_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer));
-    pm_buffer_free(&buffer);
-
-    VALUE result = rb_ary_new_capa(2);
-    rb_ary_push(result, pm_integer_new(&integer));
-    rb_ary_push(result, string);
-    pm_integer_free(&integer);
-
-    return result;
-}
-
 /**
  * call-seq:
  *   Debug::memsize(source) -> { length: xx, memsize: xx, node_count: xx }
@@ -1376,7 +1347,6 @@ Init_prism(void) {
     // internal tasks. We expose these to make them easier to test.
     VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
     rb_define_singleton_method(rb_cPrismDebug, "named_captures", named_captures, 1);
-    rb_define_singleton_method(rb_cPrismDebug, "integer_parse", integer_parse, 1);
     rb_define_singleton_method(rb_cPrismDebug, "memsize", memsize, 1);
     rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
     rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
diff --git a/prism/util/pm_integer.c b/prism/util/pm_integer.c
index 015789ccecfd1f..ab6ac78b5c3310 100644
--- a/prism/util/pm_integer.c
+++ b/prism/util/pm_integer.c
@@ -471,7 +471,7 @@ pm_integer_parse_big(pm_integer_t *integer, uint32_t multiplier, const uint8_t *
  * has already been validated, as internal validation checks are not performed
  * here.
  */
-PRISM_EXPORTED_FUNCTION void
+void
 pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end) {
     // Ignore unary +. Unary - is parsed differently and will not end up here.
     // Instead, it will modify the parsed integer later.
diff --git a/prism/util/pm_integer.h b/prism/util/pm_integer.h
index d2a1808b191336..1ede1f12b9b8ff 100644
--- a/prism/util/pm_integer.h
+++ b/prism/util/pm_integer.h
@@ -82,7 +82,7 @@ typedef enum {
  * @param start The start of the string.
  * @param end The end of the string.
  */
-PRISM_EXPORTED_FUNCTION void pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end);
+void pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end);
 
 /**
  * Return the memory size of the integer.
diff --git a/test/prism/integer_parse_test.rb b/test/prism/integer_parse_test.rb
index f42e817e7930fb..11aee174c5490a 100644
--- a/test/prism/integer_parse_test.rb
+++ b/test/prism/integer_parse_test.rb
@@ -2,8 +2,6 @@
 
 require_relative "test_helper"
 
-return if Prism::BACKEND == :FFI
-
 module Prism
   class IntegerParseTest < TestCase
     def test_integer_parse
@@ -37,9 +35,7 @@ def test_integer_parse
     private
 
     def assert_integer_parse(expected, source = expected.to_s)
-      integer, string = Debug.integer_parse(source)
-      assert_equal expected, integer
-      assert_equal expected.to_s, string
+      assert_equal expected, Prism.parse(source).value.statements.body.first.value
     end
   end
 end

From b04c959621562de18552aa1a002b52f311a7185e Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 11:35:59 -0400
Subject: [PATCH 184/242] [ruby/prism] Remove various unused memsize infra

https://github.com/ruby/prism/commit/283938ed1f
---
 prism/extension.c              | 27 --------------
 prism/node.h                   | 21 -----------
 prism/templates/src/node.c.erb | 64 ----------------------------------
 prism/util/pm_constant_pool.c  |  8 -----
 prism/util/pm_constant_pool.h  |  8 -----
 prism/util/pm_integer.c        |  8 -----
 prism/util/pm_integer.h        |  8 -----
 prism/util/pm_string.c         | 12 -------
 prism/util/pm_string.h         |  8 -----
 test/prism/memsize_test.rb     | 17 ---------
 10 files changed, 181 deletions(-)
 delete mode 100644 test/prism/memsize_test.rb

diff --git a/prism/extension.c b/prism/extension.c
index e67ea9b9dc2a6f..856bcb96544a4e 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -1065,32 +1065,6 @@ named_captures(VALUE self, VALUE source) {
     return names;
 }
 
-/**
- * call-seq:
- *   Debug::memsize(source) -> { length: xx, memsize: xx, node_count: xx }
- *
- * Return a hash of information about the given source string's memory usage.
- */
-static VALUE
-memsize(VALUE self, VALUE string) {
-    pm_parser_t parser;
-    size_t length = RSTRING_LEN(string);
-    pm_parser_init(&parser, (const uint8_t *) RSTRING_PTR(string), length, NULL);
-
-    pm_node_t *node = pm_parse(&parser);
-    pm_memsize_t memsize;
-    pm_node_memsize(node, &memsize);
-
-    pm_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, ID2SYM(rb_intern("length")), INT2FIX(length));
-    rb_hash_aset(result, ID2SYM(rb_intern("memsize")), INT2FIX(memsize.memsize));
-    rb_hash_aset(result, ID2SYM(rb_intern("node_count")), INT2FIX(memsize.node_count));
-    return result;
-}
-
 /**
  * call-seq:
  *   Debug::profile_file(filepath) -> nil
@@ -1347,7 +1321,6 @@ Init_prism(void) {
     // internal tasks. We expose these to make them easier to test.
     VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
     rb_define_singleton_method(rb_cPrismDebug, "named_captures", named_captures, 1);
-    rb_define_singleton_method(rb_cPrismDebug, "memsize", memsize, 1);
     rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
     rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
 
diff --git a/prism/node.h b/prism/node.h
index 8736e59a94d1a4..e8686a327c7c95 100644
--- a/prism/node.h
+++ b/prism/node.h
@@ -56,27 +56,6 @@ void pm_node_list_free(pm_node_list_t *list);
  */
 PRISM_EXPORTED_FUNCTION void pm_node_destroy(pm_parser_t *parser, struct pm_node *node);
 
-/**
- * This struct stores the information gathered by the pm_node_memsize function.
- * It contains both the memory footprint and additionally metadata about the
- * shape of the tree.
- */
-typedef struct {
-    /** The total memory footprint of the node and all of its children. */
-    size_t memsize;
-
-    /** The number of children the node has. */
-    size_t node_count;
-} pm_memsize_t;
-
-/**
- * Calculates the memory footprint of a given node.
- *
- * @param node The node to calculate the memory footprint of.
- * @param memsize The memory footprint of the node and all of its children.
- */
-PRISM_EXPORTED_FUNCTION void pm_node_memsize(pm_node_t *node, pm_memsize_t *memsize);
-
 /**
  * Returns a string representation of the given node type.
  *
diff --git a/prism/templates/src/node.c.erb b/prism/templates/src/node.c.erb
index e1c35f5a456f04..deb2ea49fcebbf 100644
--- a/prism/templates/src/node.c.erb
+++ b/prism/templates/src/node.c.erb
@@ -1,19 +1,6 @@
 #line <%= __LINE__ + 1 %> "<%= File.basename(__FILE__) %>"
 #include "prism/node.h"
 
-static void
-pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize);
-
-/**
- * Calculate the size of the node list in bytes.
- */
-static size_t
-pm_node_list_memsize(pm_node_list_t *node_list, pm_memsize_t *memsize) {
-    pm_node_t *node;
-    PM_NODE_LIST_FOREACH(node_list, index, node) pm_node_memsize_node(node, memsize);
-    return sizeof(pm_node_list_t) + (node_list->capacity * sizeof(pm_node_t *));
-}
-
 /**
  * Attempts to grow the node list to the next size. If there is already
  * capacity in the list, this function does nothing. Otherwise it reallocates
@@ -156,57 +143,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
     xfree(node);
 }
 
-static void
-pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
-    memsize->node_count++;
-
-    switch (PM_NODE_TYPE(node)) {
-        // We do not calculate memsize of a ScopeNode
-        // as it should never be generated
-        case PM_SCOPE_NODE:
-            return;
-        <%- nodes.each do |node| -%>
-#line <%= __LINE__ + 1 %> "<%= File.basename(__FILE__) %>"
-        case <%= node.type %>: {
-            pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
-            memsize->memsize += sizeof(*cast);
-            <%- node.fields.each do |field| -%>
-            <%- case field -%>
-            <%- when Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::FlagsField, Prism::Template::LocationField, Prism::Template::OptionalLocationField, Prism::Template::DoubleField -%>
-            <%- when Prism::Template::NodeField -%>
-            pm_node_memsize_node((pm_node_t *)cast-><%= field.name %>, memsize);
-            <%- when Prism::Template::OptionalNodeField -%>
-            if (cast-><%= field.name %> != NULL) {
-                pm_node_memsize_node((pm_node_t *)cast-><%= field.name %>, memsize);
-            }
-            <%- when Prism::Template::StringField -%>
-            memsize->memsize += (pm_string_memsize(&cast-><%= field.name %>) - sizeof(pm_string_t));
-            <%- when Prism::Template::NodeListField -%>
-            memsize->memsize += (pm_node_list_memsize(&cast-><%= field.name %>, memsize) - sizeof(pm_node_list_t));
-            <%- when Prism::Template::ConstantListField -%>
-            memsize->memsize += (pm_constant_id_list_memsize(&cast-><%= field.name %>) - sizeof(pm_constant_id_list_t));
-            <%- when Prism::Template::IntegerField -%>
-            memsize->memsize += (pm_integer_memsize(&cast-><%= field.name %>) - sizeof(pm_integer_t));
-            <%- else -%>
-            <%- raise -%>
-            <%- end -%>
-            <%- end -%>
-            break;
-        }
-        <%- end -%>
-#line <%= __LINE__ + 1 %> "<%= File.basename(__FILE__) %>"
-    }
-}
-
-/**
- * Calculates the memory footprint of a given node.
- */
-PRISM_EXPORTED_FUNCTION void
-pm_node_memsize(pm_node_t *node, pm_memsize_t *memsize) {
-    *memsize = (pm_memsize_t) { .memsize = 0, .node_count = 0 };
-    pm_node_memsize_node(node, memsize);
-}
-
 /**
  * Returns a string representation of the given node type.
  */
diff --git a/prism/util/pm_constant_pool.c b/prism/util/pm_constant_pool.c
index 2a3203f4c46c82..624002cec9fd39 100644
--- a/prism/util/pm_constant_pool.c
+++ b/prism/util/pm_constant_pool.c
@@ -61,14 +61,6 @@ pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id) {
     return false;
 }
 
-/**
- * Get the memory size of a list of constant ids.
- */
-size_t
-pm_constant_id_list_memsize(pm_constant_id_list_t *list) {
-    return sizeof(pm_constant_id_list_t) + (list->capacity * sizeof(pm_constant_id_t));
-}
-
 /**
  * Free the memory associated with a list of constant ids.
  */
diff --git a/prism/util/pm_constant_pool.h b/prism/util/pm_constant_pool.h
index 0fe16858a0dea7..6df23f8f501d38 100644
--- a/prism/util/pm_constant_pool.h
+++ b/prism/util/pm_constant_pool.h
@@ -87,14 +87,6 @@ void pm_constant_id_list_insert(pm_constant_id_list_t *list, size_t index, pm_co
  */
 bool pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id);
 
-/**
- * Get the memory size of a list of constant ids.
- *
- * @param list The list to get the memory size of.
- * @return The memory size of the list.
- */
-size_t pm_constant_id_list_memsize(pm_constant_id_list_t *list);
-
 /**
  * Free the memory associated with a list of constant ids.
  *
diff --git a/prism/util/pm_integer.c b/prism/util/pm_integer.c
index ab6ac78b5c3310..137f7365369fcc 100644
--- a/prism/util/pm_integer.c
+++ b/prism/util/pm_integer.c
@@ -536,14 +536,6 @@ pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *s
     integer->value = (uint32_t) value;
 }
 
-/**
- * Return the memory size of the integer.
- */
-size_t
-pm_integer_memsize(const pm_integer_t *integer) {
-    return sizeof(pm_integer_t) + integer->length * sizeof(uint32_t);
-}
-
 /**
  * Compare two integers. This function returns -1 if the left integer is less
  * than the right integer, 0 if they are equal, and 1 if the left integer is
diff --git a/prism/util/pm_integer.h b/prism/util/pm_integer.h
index 1ede1f12b9b8ff..91b28ad2f34ed2 100644
--- a/prism/util/pm_integer.h
+++ b/prism/util/pm_integer.h
@@ -84,14 +84,6 @@ typedef enum {
  */
 void pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end);
 
-/**
- * Return the memory size of the integer.
- *
- * @param integer The integer to get the memory size of.
- * @return The size of the memory associated with the integer.
- */
-size_t pm_integer_memsize(const pm_integer_t *integer);
-
 /**
  * Compare two integers. This function returns -1 if the left integer is less
  * than the right integer, 0 if they are equal, and 1 if the left integer is
diff --git a/prism/util/pm_string.c b/prism/util/pm_string.c
index 8342edc34ef973..dfc121b6a2735a 100644
--- a/prism/util/pm_string.c
+++ b/prism/util/pm_string.c
@@ -245,18 +245,6 @@ pm_string_file_init(pm_string_t *string, const char *filepath) {
 #endif
 }
 
-/**
- * Returns the memory size associated with the string.
- */
-size_t
-pm_string_memsize(const pm_string_t *string) {
-    size_t size = sizeof(pm_string_t);
-    if (string->type == PM_STRING_OWNED) {
-        size += string->length;
-    }
-    return size;
-}
-
 /**
  * Ensure the string is owned. If it is not, then reinitialize it as owned and
  * copy over the previous source.
diff --git a/prism/util/pm_string.h b/prism/util/pm_string.h
index a68e2a7c912233..d23792c0bad098 100644
--- a/prism/util/pm_string.h
+++ b/prism/util/pm_string.h
@@ -120,14 +120,6 @@ PRISM_EXPORTED_FUNCTION bool pm_string_mapped_init(pm_string_t *string, const ch
  */
 PRISM_EXPORTED_FUNCTION bool pm_string_file_init(pm_string_t *string, const char *filepath);
 
-/**
- * Returns the memory size associated with the string.
- *
- * @param string The string to get the memory size of.
- * @return The size of the memory associated with the string.
- */
-size_t pm_string_memsize(const pm_string_t *string);
-
 /**
  * Ensure the string is owned. If it is not, then reinitialize it as owned and
  * copy over the previous source.
diff --git a/test/prism/memsize_test.rb b/test/prism/memsize_test.rb
deleted file mode 100644
index d7e1448dbc0ec3..00000000000000
--- a/test/prism/memsize_test.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-return if Prism::BACKEND == :FFI
-
-module Prism
-  class MemsizeTest < TestCase
-    def test_memsize
-      result = Debug.memsize("2 + 3")
-
-      assert_equal 5, result[:length]
-      assert_kind_of Integer, result[:memsize]
-      assert_equal 6, result[:node_count]
-    end
-  end
-end

From e1041a8eda151d8b77596c1989b12fcc92deff2c Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 11:53:54 -0400
Subject: [PATCH 185/242] [ruby/prism] Move profiling to prism module directly

https://github.com/ruby/prism/commit/75fabf7081
---
 prism/extension.c | 195 +++++++++++++++++++++++++---------------------
 1 file changed, 105 insertions(+), 90 deletions(-)

diff --git a/prism/extension.c b/prism/extension.c
index 856bcb96544a4e..f4d7674de61419 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -25,14 +25,14 @@ VALUE rb_cPrismParseLexResult;
 
 VALUE rb_cPrismDebugEncoding;
 
-ID rb_option_id_command_line;
-ID rb_option_id_encoding;
-ID rb_option_id_filepath;
-ID rb_option_id_frozen_string_literal;
-ID rb_option_id_line;
-ID rb_option_id_scopes;
-ID rb_option_id_version;
-ID rb_prism_source_id_for;
+ID rb_id_option_command_line;
+ID rb_id_option_encoding;
+ID rb_id_option_filepath;
+ID rb_id_option_frozen_string_literal;
+ID rb_id_option_line;
+ID rb_id_option_scopes;
+ID rb_id_option_version;
+ID rb_id_source_for;
 
 /******************************************************************************/
 /* IO of Ruby code                                                            */
@@ -135,15 +135,15 @@ build_options_i(VALUE key, VALUE value, VALUE argument) {
     pm_options_t *options = (pm_options_t *) argument;
     ID key_id = SYM2ID(key);
 
-    if (key_id == rb_option_id_filepath) {
+    if (key_id == rb_id_option_filepath) {
         if (!NIL_P(value)) pm_options_filepath_set(options, check_string(value));
-    } else if (key_id == rb_option_id_encoding) {
+    } else if (key_id == rb_id_option_encoding) {
         if (!NIL_P(value)) pm_options_encoding_set(options, rb_enc_name(rb_to_encoding(value)));
-    } else if (key_id == rb_option_id_line) {
+    } else if (key_id == rb_id_option_line) {
         if (!NIL_P(value)) pm_options_line_set(options, NUM2INT(value));
-    } else if (key_id == rb_option_id_frozen_string_literal) {
+    } else if (key_id == rb_id_option_frozen_string_literal) {
         if (!NIL_P(value)) pm_options_frozen_string_literal_set(options, RTEST(value));
-    } else if (key_id == rb_option_id_version) {
+    } else if (key_id == rb_id_option_version) {
         if (!NIL_P(value)) {
             const char *version = check_string(value);
 
@@ -151,9 +151,9 @@ build_options_i(VALUE key, VALUE value, VALUE argument) {
                 rb_raise(rb_eArgError, "invalid version: %" PRIsVALUE, value);
             }
         }
-    } else if (key_id == rb_option_id_scopes) {
+    } else if (key_id == rb_id_option_scopes) {
         if (!NIL_P(value)) build_options_scopes(options, value);
-    } else if (key_id == rb_option_id_command_line) {
+    } else if (key_id == rb_id_option_command_line) {
         if (!NIL_P(value)) {
             const char *string = check_string(value);
             uint8_t command_line = 0;
@@ -600,7 +600,7 @@ parse_lex_input(pm_string_t *input, const pm_options_t *options, bool return_nod
 
     VALUE source_string = rb_str_new((const char *) pm_string_source(input), pm_string_length(input));
     VALUE offsets = rb_ary_new();
-    VALUE source = rb_funcall(rb_cPrismSource, rb_prism_source_id_for, 3, source_string, LONG2NUM(parser.start_line), offsets);
+    VALUE source = rb_funcall(rb_cPrismSource, rb_id_source_for, 3, source_string, LONG2NUM(parser.start_line), offsets);
 
     parse_lex_data_t parse_lex_data = {
         .source = source,
@@ -761,6 +761,82 @@ parse(int argc, VALUE *argv, VALUE self) {
     return value;
 }
 
+/**
+ * call-seq:
+ *   Prism::parse_file(filepath, **options) -> ParseResult
+ *
+ * Parse the given file and return a ParseResult instance. For supported
+ * options, see Prism::parse.
+ */
+static VALUE
+parse_file(int argc, VALUE *argv, VALUE self) {
+    pm_string_t input;
+    pm_options_t options = { 0 };
+
+    file_options(argc, argv, &input, &options);
+
+    VALUE value = parse_input(&input, &options);
+    pm_string_free(&input);
+    pm_options_free(&options);
+
+    return value;
+}
+
+/**
+ * Parse the given input and return nothing.
+ */
+static void
+profile_input(pm_string_t *input, const pm_options_t *options) {
+    pm_parser_t parser;
+    pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options);
+
+    pm_node_t *node = pm_parse(&parser);
+    pm_node_destroy(&parser, node);
+    pm_parser_free(&parser);
+}
+
+/**
+ * call-seq:
+ *   Prism::profile(source, **options) -> nil
+ *
+ * Parse the given string and return nothing. This method is meant to allow
+ * profilers to avoid the overhead of reifying the AST to Ruby. For supported
+ * options, see Prism::parse.
+ */
+static VALUE
+profile(int argc, VALUE *argv, VALUE self) {
+    pm_string_t input;
+    pm_options_t options = { 0 };
+
+    string_options(argc, argv, &input, &options);
+    profile_input(&input, &options);
+    pm_string_free(&input);
+    pm_options_free(&options);
+
+    return Qnil;
+}
+
+/**
+ * call-seq:
+ *   Prism::profile_file(filepath, **options) -> nil
+ *
+ * Parse the given file and return nothing. This method is meant to allow
+ * profilers to avoid the overhead of reifying the AST to Ruby. For supported
+ * options, see Prism::parse.
+ */
+static VALUE
+profile_file(int argc, VALUE *argv, VALUE self) {
+    pm_string_t input;
+    pm_options_t options = { 0 };
+
+    file_options(argc, argv, &input, &options);
+    profile_input(&input, &options);
+    pm_string_free(&input);
+    pm_options_free(&options);
+
+    return Qnil;
+}
+
 /**
  * An implementation of fgets that is suitable for use with Ruby IO objects.
  */
@@ -815,27 +891,6 @@ parse_stream(int argc, VALUE *argv, VALUE self) {
     return result;
 }
 
-/**
- * call-seq:
- *   Prism::parse_file(filepath, **options) -> ParseResult
- *
- * Parse the given file and return a ParseResult instance. For supported
- * options, see Prism::parse.
- */
-static VALUE
-parse_file(int argc, VALUE *argv, VALUE self) {
-    pm_string_t input;
-    pm_options_t options = { 0 };
-
-    file_options(argc, argv, &input, &options);
-
-    VALUE value = parse_input(&input, &options);
-    pm_string_free(&input);
-    pm_options_free(&options);
-
-    return value;
-}
-
 /**
  * Parse the given input and return an array of Comment objects.
  */
@@ -1065,45 +1120,6 @@ named_captures(VALUE self, VALUE source) {
     return names;
 }
 
-/**
- * call-seq:
- *   Debug::profile_file(filepath) -> nil
- *
- * Parse the file, but do nothing with the result. This is used to profile the
- * parser for memory and speed.
- */
-static VALUE
-profile_file(VALUE self, VALUE filepath) {
-    pm_string_t input;
-
-    const char *checked = check_string(filepath);
-    Check_Type(filepath, T_STRING);
-
-    if (!pm_string_mapped_init(&input, checked)) {
-#ifdef _WIN32
-        int e = rb_w32_map_errno(GetLastError());
-#else
-        int e = errno;
-#endif
-
-        rb_syserr_fail(e, checked);
-    }
-
-    pm_options_t options = { 0 };
-    pm_options_filepath_set(&options, checked);
-
-    pm_parser_t parser;
-    pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), &options);
-
-    pm_node_t *node = pm_parse(&parser);
-    pm_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-    pm_options_free(&options);
-    pm_string_free(&input);
-
-    return Qnil;
-}
-
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
 
 /**
@@ -1275,22 +1291,20 @@ Init_prism(void) {
     rb_cPrismMagicComment = rb_define_class_under(rb_cPrism, "MagicComment", rb_cObject);
     rb_cPrismParseError = rb_define_class_under(rb_cPrism, "ParseError", rb_cObject);
     rb_cPrismParseWarning = rb_define_class_under(rb_cPrism, "ParseWarning", rb_cObject);
-
     rb_cPrismResult = rb_define_class_under(rb_cPrism, "Result", rb_cObject);
     rb_cPrismParseResult = rb_define_class_under(rb_cPrism, "ParseResult", rb_cPrismResult);
     rb_cPrismParseLexResult = rb_define_class_under(rb_cPrism, "ParseLexResult", rb_cPrismResult);
 
-    // Intern all of the options that we support so that we don't have to do it
-    // every time we parse.
-    rb_option_id_command_line = rb_intern_const("command_line");
-    rb_option_id_encoding = rb_intern_const("encoding");
-    rb_option_id_filepath = rb_intern_const("filepath");
-    rb_option_id_frozen_string_literal = rb_intern_const("frozen_string_literal");
-    rb_option_id_line = rb_intern_const("line");
-    rb_option_id_scopes = rb_intern_const("scopes");
-    rb_option_id_version = rb_intern_const("version");
-
-    rb_prism_source_id_for = rb_intern("for");
+    // Intern all of the IDs eagerly that we support so that we don't have to do
+    // it every time we parse.
+    rb_id_option_command_line = rb_intern_const("command_line");
+    rb_id_option_encoding = rb_intern_const("encoding");
+    rb_id_option_filepath = rb_intern_const("filepath");
+    rb_id_option_frozen_string_literal = rb_intern_const("frozen_string_literal");
+    rb_id_option_line = rb_intern_const("line");
+    rb_id_option_scopes = rb_intern_const("scopes");
+    rb_id_option_version = rb_intern_const("version");
+    rb_id_source_for = rb_intern("for");
 
     /**
      * The version of the prism library.
@@ -1301,8 +1315,10 @@ Init_prism(void) {
     rb_define_singleton_method(rb_cPrism, "lex", lex, -1);
     rb_define_singleton_method(rb_cPrism, "lex_file", lex_file, -1);
     rb_define_singleton_method(rb_cPrism, "parse", parse, -1);
-    rb_define_singleton_method(rb_cPrism, "parse_stream", parse_stream, -1);
     rb_define_singleton_method(rb_cPrism, "parse_file", parse_file, -1);
+    rb_define_singleton_method(rb_cPrism, "profile", profile, -1);
+    rb_define_singleton_method(rb_cPrism, "profile_file", profile_file, -1);
+    rb_define_singleton_method(rb_cPrism, "parse_stream", parse_stream, -1);
     rb_define_singleton_method(rb_cPrism, "parse_comments", parse_comments, -1);
     rb_define_singleton_method(rb_cPrism, "parse_file_comments", parse_file_comments, -1);
     rb_define_singleton_method(rb_cPrism, "parse_lex", parse_lex, -1);
@@ -1321,7 +1337,6 @@ Init_prism(void) {
     // internal tasks. We expose these to make them easier to test.
     VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
     rb_define_singleton_method(rb_cPrismDebug, "named_captures", named_captures, 1);
-    rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
     rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
 
 #ifndef PRISM_EXCLUDE_PRETTYPRINT

From 653652bcbe0735d44e380da2fef7a553b9cd1ac7 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 12:04:04 -0400
Subject: [PATCH 186/242] [ruby/prism] Remove Debug#named_captures

https://github.com/ruby/prism/commit/5050dfbe70
---
 prism/extension.c         |  28 ---------
 test/prism/regexp_test.rb | 120 +++++++++++++++++++-------------------
 2 files changed, 59 insertions(+), 89 deletions(-)

diff --git a/prism/extension.c b/prism/extension.c
index f4d7674de61419..3d118b1edd8903 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -1093,33 +1093,6 @@ parse_file_failure_p(int argc, VALUE *argv, VALUE self) {
 /* Utility functions exposed to make testing easier                           */
 /******************************************************************************/
 
-/**
- * call-seq:
- *   Debug::named_captures(source) -> Array
- *
- * Returns an array of strings corresponding to the named capture groups in the
- * given source string. If prism was unable to parse the regular expression,
- * this function returns nil.
- */
-static VALUE
-named_captures(VALUE self, VALUE source) {
-    pm_string_list_t string_list = { 0 };
-
-    if (!pm_regexp_named_capture_group_names((const uint8_t *) RSTRING_PTR(source), RSTRING_LEN(source), &string_list, false, PM_ENCODING_UTF_8_ENTRY)) {
-        pm_string_list_free(&string_list);
-        return Qnil;
-    }
-
-    VALUE names = rb_ary_new();
-    for (size_t index = 0; index < string_list.length; index++) {
-        const pm_string_t *string = &string_list.strings[index];
-        rb_ary_push(names, rb_str_new((const char *) pm_string_source(string), pm_string_length(string)));
-    }
-
-    pm_string_list_free(&string_list);
-    return names;
-}
-
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
 
 /**
@@ -1336,7 +1309,6 @@ Init_prism(void) {
     // Next, the functions that will be called by the parser to perform various
     // internal tasks. We expose these to make them easier to test.
     VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
-    rb_define_singleton_method(rb_cPrismDebug, "named_captures", named_captures, 1);
     rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
 
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
diff --git a/test/prism/regexp_test.rb b/test/prism/regexp_test.rb
index 0a5fc2b4fc4ac6..35be217f793bfb 100644
--- a/test/prism/regexp_test.rb
+++ b/test/prism/regexp_test.rb
@@ -2,78 +2,84 @@
 
 require_relative "test_helper"
 
-return if Prism::BACKEND == :FFI
-
 module Prism
   class RegexpTest < TestCase
-    ##############################################################################
+    ############################################################################
     # These tests test the actual use case of extracting named capture groups
-    ##############################################################################
+    ############################################################################
 
     def test_named_captures_with_arrows
-      assert_equal(["foo"], named_captures("(?<foo>bar)"))
+      assert_equal([:foo], named_captures("(?<foo>bar)"))
     end
 
     def test_named_captures_with_single_quotes
-      assert_equal(["foo"], named_captures("(?'foo'bar)"))
+      assert_equal([:foo], named_captures("(?'foo'bar)"))
     end
 
     def test_nested_named_captures_with_arrows
-      assert_equal(["foo", "bar"], named_captures("(?<foo>(?<bar>baz))"))
+      assert_equal([:foo, :bar], named_captures("(?<foo>(?<bar>baz))"))
     end
 
     def test_nested_named_captures_with_single_quotes
-      assert_equal(["foo", "bar"], named_captures("(?'foo'(?'bar'baz))"))
+      assert_equal([:foo, :bar], named_captures("(?'foo'(?'bar'baz))"))
     end
 
     def test_allows_duplicate_named_captures
-      assert_equal(["foo", "foo"], named_captures("(?<foo>bar)(?<foo>baz)"))
+      assert_equal([:foo], named_captures("(?<foo>bar)(?<foo>baz)"))
     end
 
     def test_named_capture_inside_fake_range_quantifier
-      assert_equal(["foo"], named_captures("foo{1, (?<foo>2)}"))
+      assert_equal([:foo], named_captures("foo{1, (?<foo>2)}"))
+    end
+
+    def test_fake_named_captures_inside_character_sets
+      assert_equal([], named_captures("[a-z(?<foo>)]"))
     end
 
-    ##############################################################################
+    def test_fake_named_capture_inside_character_set_with_escaped_ending
+      assert_equal([], named_captures("[a-z\\](?<foo>)]"))
+    end
+
+    ############################################################################
     # These tests test the rest of the AST. They are not exhaustive, but they
     # should cover the most common cases. We test these to make sure we don't
     # accidentally regress and stop being able to extract named captures.
-    ##############################################################################
+    ############################################################################
 
     def test_alternation
-      refute_nil(named_captures("foo|bar"))
+      assert_valid_regexp("foo|bar")
     end
 
     def test_anchors
-      refute_nil(named_captures("^foo$"))
+      assert_valid_regexp("^foo$")
     end
 
     def test_any
-      refute_nil(named_captures("."))
+      assert_valid_regexp(".")
     end
 
     def test_posix_character_classes
-      refute_nil(named_captures("[[:digit:]]"))
+      assert_valid_regexp("[[:digit:]]")
     end
 
     def test_negated_posix_character_classes
-      refute_nil(named_captures("[[:^digit:]]"))
+      assert_valid_regexp("[[:^digit:]]")
     end
 
     def test_invalid_posix_character_classes_should_fall_back_to_regular_classes
-      refute_nil(named_captures("[[:foo]]"))
+      assert_valid_regexp("[[:foo]]")
     end
 
     def test_character_sets
-      refute_nil(named_captures("[abc]"))
+      assert_valid_regexp("[abc]")
     end
 
     def test_nested_character_sets
-      refute_nil(named_captures("[[abc]]"))
+      assert_valid_regexp("[[abc]]")
     end
 
     def test_nested_character_sets_with_operators
-      refute_nil(named_captures("[[abc] && [def]]"))
+      assert_valid_regexp("[[abc] && [def]]")
     end
 
     def test_named_capture_inside_nested_character_set
@@ -81,120 +87,108 @@ def test_named_capture_inside_nested_character_set
     end
 
     def test_negated_character_sets
-      refute_nil(named_captures("[^abc]"))
+      assert_valid_regexp("[^abc]")
     end
 
     def test_character_ranges
-      refute_nil(named_captures("[a-z]"))
+      assert_valid_regexp("[a-z]")
     end
 
     def test_negated_character_ranges
-      refute_nil(named_captures("[^a-z]"))
-    end
-
-    def test_fake_named_captures_inside_character_sets
-      assert_equal([], named_captures("[a-z(?<foo>)]"))
-    end
-
-    def test_fake_named_capture_inside_character_set_with_escaped_ending
-      assert_equal([], named_captures("[a-z\\](?<foo>)]"))
+      assert_valid_regexp("[^a-z]")
     end
 
     def test_comments
-      refute_nil(named_captures("(?#foo)"))
+      assert_valid_regexp("(?#foo)")
     end
 
     def test_comments_with_escaped_parentheses
-      refute_nil(named_captures("(?#foo\\)\\))"))
+      assert_valid_regexp("(?#foo\\)\\))")
     end
 
     def test_non_capturing_groups
-      refute_nil(named_captures("(?:foo)"))
+      assert_valid_regexp("(?:foo)")
     end
 
     def test_positive_lookaheads
-      refute_nil(named_captures("(?=foo)"))
+      assert_valid_regexp("(?=foo)")
     end
 
     def test_negative_lookaheads
-      refute_nil(named_captures("(?!foo)"))
+      assert_valid_regexp("(?!foo)")
     end
 
     def test_positive_lookbehinds
-      refute_nil(named_captures("(?<=foo)"))
+      assert_valid_regexp("(?<=foo)")
     end
 
     def test_negative_lookbehinds
-      refute_nil(named_captures("(?<!foo)"))
+      assert_valid_regexp("(?<!foo)")
     end
 
     def test_atomic_groups
-      refute_nil(named_captures("(?>foo)"))
+      assert_valid_regexp("(?>foo)")
     end
 
     def test_absence_operator
-      refute_nil(named_captures("(?~foo)"))
+      assert_valid_regexp("(?~foo)")
     end
 
     def test_conditional_expression_with_index
-      refute_nil(named_captures("(?(1)foo)"))
+      assert_valid_regexp("(?(1)foo)")
     end
 
     def test_conditional_expression_with_name
-      refute_nil(named_captures("(?(foo)bar)"))
+      assert_valid_regexp("(?(foo)bar)")
     end
 
     def test_conditional_expression_with_group
-      refute_nil(named_captures("(?(<foo>)bar)"))
+      assert_valid_regexp("(?(<foo>)bar)")
     end
 
     def test_options_on_groups
-      refute_nil(named_captures("(?imxdau:foo)"))
-    end
-
-    def test_options_on_groups_with_invalid_options
-      assert_nil(named_captures("(?z:bar)"))
+      assert_valid_regexp("(?imxdau:foo)")
     end
 
     def test_options_on_groups_getting_turned_off
-      refute_nil(named_captures("(?-imx:foo)"))
+      assert_valid_regexp("(?-imx:foo)")
     end
 
     def test_options_on_groups_some_getting_turned_on_some_getting_turned_off
-      refute_nil(named_captures("(?im-x:foo)"))
+      assert_valid_regexp("(?im-x:foo)")
     end
 
     def test_star_quantifier
-      refute_nil(named_captures("foo*"))
+      assert_valid_regexp("foo*")
     end
 
     def test_plus_quantifier
-      refute_nil(named_captures("foo+"))
+      assert_valid_regexp("foo+")
     end
 
     def test_question_mark_quantifier
-      refute_nil(named_captures("foo?"))
+      assert_valid_regexp("foo?")
     end
 
     def test_endless_range_quantifier
-      refute_nil(named_captures("foo{1,}"))
+      assert_valid_regexp("foo{1,}")
     end
 
     def test_beginless_range_quantifier
-      refute_nil(named_captures("foo{,1}"))
+      assert_valid_regexp("foo{,1}")
     end
 
     def test_range_quantifier
-      refute_nil(named_captures("foo{1,2}"))
+      assert_valid_regexp("foo{1,2}")
     end
 
     def test_fake_range_quantifier_because_of_spaces
-      refute_nil(named_captures("foo{1, 2}"))
+      assert_valid_regexp("foo{1, 2}")
     end
 
-    ##############################################################################
+    ############################################################################
     # These test that flag values are correct.
-    ##############################################################################
+    ############################################################################
 
     def test_flag_ignorecase
       assert_equal(Regexp::IGNORECASE, options("i"))
@@ -241,8 +235,12 @@ def test_last_encoding_option_wins
 
     private
 
+    def assert_valid_regexp(source)
+      assert Prism.parse_success?("/#{source}/ =~ \"\"")
+    end
+
     def named_captures(source)
-      Debug.named_captures(source)
+      Prism.parse("/#{source}/ =~ \"\"").value.locals
     end
 
     def options(flags)

From 79001c8b4a35f12b6115916de2f2671168b97ae1 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 12:14:35 -0400
Subject: [PATCH 187/242] [ruby/prism] Remove error formatting, put directly in
 CRuby

https://github.com/ruby/prism/commit/53b2866487
---
 prism/extension.c                |  31 ---
 prism/prism.c                    | 362 -------------------------------
 prism/prism.h                    |  11 -
 test/prism/format_errors_test.rb |  58 -----
 test/prism/newline_test.rb       |   1 -
 5 files changed, 463 deletions(-)
 delete mode 100644 test/prism/format_errors_test.rb

diff --git a/prism/extension.c b/prism/extension.c
index 3d118b1edd8903..a0a044f8fb27ca 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -1127,36 +1127,6 @@ inspect_node(VALUE self, VALUE source) {
 
 #endif
 
-/**
- * call-seq:
- *   Debug::format_errors(source, colorize) -> String
- *
- * Format the errors that are found when parsing the given source string.
- */
-static VALUE
-format_errors(VALUE self, VALUE source, VALUE colorize) {
-    pm_string_t input;
-    input_load_string(&input, source);
-
-    pm_parser_t parser;
-    pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), NULL);
-
-    pm_node_t *node = pm_parse(&parser);
-    pm_buffer_t buffer = { 0 };
-
-    pm_parser_errors_format(&parser, &parser.error_list, &buffer, RTEST(colorize), true);
-
-    rb_encoding *encoding = rb_enc_find(parser.encoding->name);
-    VALUE result = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), encoding);
-
-    pm_buffer_free(&buffer);
-    pm_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-    pm_string_free(&input);
-
-    return result;
-}
-
 /**
  * call-seq: Debug::Encoding.all -> Array[Debug::Encoding]
  *
@@ -1309,7 +1279,6 @@ Init_prism(void) {
     // Next, the functions that will be called by the parser to perform various
     // internal tasks. We expose these to make them easier to test.
     VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
-    rb_define_singleton_method(rb_cPrismDebug, "format_errors", format_errors, 2);
 
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
     rb_define_singleton_method(rb_cPrismDebug, "inspect_node", inspect_node, 1);
diff --git a/prism/prism.c b/prism/prism.c
index 385c64595b309b..418aa93d2cda54 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -21675,365 +21675,3 @@ pm_serialize_parse_comments(pm_buffer_t *buffer, const uint8_t *source, size_t s
 }
 
 #endif
-
-/** An error that is going to be formatted into the output. */
-typedef struct {
-    /** A pointer to the diagnostic that was generated during parsing. */
-    pm_diagnostic_t *error;
-
-    /** The start line of the diagnostic message. */
-    int32_t line;
-
-    /** The column start of the diagnostic message. */
-    uint32_t column_start;
-
-    /** The column end of the diagnostic message. */
-    uint32_t column_end;
-} pm_error_t;
-
-/** The format that will be used to format the errors into the output. */
-typedef struct {
-    /** The prefix that will be used for line numbers. */
-    const char *number_prefix;
-
-    /** The prefix that will be used for blank lines. */
-    const char *blank_prefix;
-
-    /** The divider that will be used between sections of source code. */
-    const char *divider;
-
-    /** The length of the blank prefix. */
-    size_t blank_prefix_length;
-
-    /** The length of the divider. */
-    size_t divider_length;
-} pm_error_format_t;
-
-#define PM_COLOR_GRAY "\033[38;5;102m"
-#define PM_COLOR_RED "\033[1;31m"
-#define PM_COLOR_RESET "\033[m"
-#define PM_ERROR_TRUNCATE 30
-
-static inline pm_error_t *
-pm_parser_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
-    pm_error_t *errors = xcalloc(error_list->size, sizeof(pm_error_t));
-    if (errors == NULL) return NULL;
-
-    int32_t start_line = parser->start_line;
-    for (pm_diagnostic_t *error = (pm_diagnostic_t *) error_list->head; error != NULL; error = (pm_diagnostic_t *) error->node.next) {
-        pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.start, start_line);
-        pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
-
-        // We're going to insert this error into the array in sorted order. We
-        // do this by finding the first error that has a line number greater
-        // than the current error and then inserting the current error before
-        // that one.
-        size_t index = 0;
-        while (
-            (index < error_list->size) &&
-            (errors[index].error != NULL) &&
-            (
-                (errors[index].line < start.line) ||
-                ((errors[index].line == start.line) && (errors[index].column_start < start.column))
-            )
-        ) index++;
-
-        // Now we're going to shift all of the errors after this one down one
-        // index to make room for the new error.
-        if (index + 1 < error_list->size) {
-            memmove(&errors[index + 1], &errors[index], sizeof(pm_error_t) * (error_list->size - index - 1));
-        }
-
-        // Finally, we'll insert the error into the array.
-        uint32_t column_end;
-        if (start.line == end.line) {
-            column_end = end.column;
-        } else {
-            column_end = (uint32_t) (newline_list->offsets[start.line - start_line + 1] - newline_list->offsets[start.line - start_line] - 1);
-        }
-
-        // Ensure we have at least one column of error.
-        if (start.column == column_end) column_end++;
-
-        errors[index] = (pm_error_t) {
-            .error = error,
-            .line = start.line,
-            .column_start = start.column,
-            .column_end = column_end
-        };
-    }
-
-    return errors;
-}
-
-static inline void
-pm_parser_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t *newline_list, const char *number_prefix, int32_t line, uint32_t column_start, uint32_t column_end, pm_buffer_t *buffer) {
-    int32_t line_delta = line - parser->start_line;
-    assert(line_delta >= 0);
-
-    size_t index = (size_t) line_delta;
-    assert(index < newline_list->size);
-
-    const uint8_t *start = &parser->start[newline_list->offsets[index]];
-    const uint8_t *end;
-
-    if (index >= newline_list->size - 1) {
-        end = parser->end;
-    } else {
-        end = &parser->start[newline_list->offsets[index + 1]];
-    }
-
-    pm_buffer_append_format(buffer, number_prefix, line);
-
-    // Here we determine if we should truncate the end of the line.
-    bool truncate_end = false;
-    if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
-        end = start + column_end + PM_ERROR_TRUNCATE;
-        truncate_end = true;
-    }
-
-    // Here we determine if we should truncate the start of the line.
-    if (column_start >= PM_ERROR_TRUNCATE) {
-        pm_buffer_append_string(buffer, "... ", 4);
-        start += column_start;
-    }
-
-    pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
-
-    if (truncate_end) {
-        pm_buffer_append_string(buffer, " ...\n", 5);
-    } else if (end == parser->end && end[-1] != '\n') {
-        pm_buffer_append_string(buffer, "\n", 1);
-    }
-}
-
-/**
- * Format the errors on the parser into the given buffer.
- */
-PRISM_EXPORTED_FUNCTION void
-pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, bool colorize, bool inline_messages) {
-    assert(error_list->size != 0);
-
-    // First, we're going to sort all of the errors by line number using an
-    // insertion sort into a newly allocated array.
-    const int32_t start_line = parser->start_line;
-    const pm_newline_list_t *newline_list = &parser->newline_list;
-
-    pm_error_t *errors = pm_parser_errors_format_sort(parser, error_list, newline_list);
-    if (errors == NULL) return;
-
-    // Now we're going to determine how we're going to format line numbers and
-    // blank lines based on the maximum number of digits in the line numbers
-    // that are going to be displaid.
-    pm_error_format_t error_format;
-    int32_t first_line_number = errors[0].line;
-    int32_t last_line_number = errors[error_list->size - 1].line;
-
-    // If we have a maximum line number that is negative, then we're going to
-    // use the absolute value for comparison but multiple by 10 to additionally
-    // have a column for the negative sign.
-    if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
-    if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
-    int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
-
-    if (max_line_number < 10) {
-        if (colorize) {
-            error_format = (pm_error_format_t) {
-                .number_prefix = PM_COLOR_GRAY "%1" PRIi32 " | " PM_COLOR_RESET,
-                .blank_prefix = PM_COLOR_GRAY "  | " PM_COLOR_RESET,
-                .divider = PM_COLOR_GRAY "  ~~~~~" PM_COLOR_RESET "\n"
-            };
-        } else {
-            error_format = (pm_error_format_t) {
-                .number_prefix = "%1" PRIi32 " | ",
-                .blank_prefix = "  | ",
-                .divider = "  ~~~~~\n"
-            };
-        }
-    } else if (max_line_number < 100) {
-        if (colorize) {
-            error_format = (pm_error_format_t) {
-                .number_prefix = PM_COLOR_GRAY "%2" PRIi32 " | " PM_COLOR_RESET,
-                .blank_prefix = PM_COLOR_GRAY "   | " PM_COLOR_RESET,
-                .divider = PM_COLOR_GRAY "  ~~~~~~" PM_COLOR_RESET "\n"
-            };
-        } else {
-            error_format = (pm_error_format_t) {
-                .number_prefix = "%2" PRIi32 " | ",
-                .blank_prefix = "   | ",
-                .divider = "  ~~~~~~\n"
-            };
-        }
-    } else if (max_line_number < 1000) {
-        if (colorize) {
-            error_format = (pm_error_format_t) {
-                .number_prefix = PM_COLOR_GRAY "%3" PRIi32 " | " PM_COLOR_RESET,
-                .blank_prefix = PM_COLOR_GRAY "    | " PM_COLOR_RESET,
-                .divider = PM_COLOR_GRAY "  ~~~~~~~" PM_COLOR_RESET "\n"
-            };
-        } else {
-            error_format = (pm_error_format_t) {
-                .number_prefix = "%3" PRIi32 " | ",
-                .blank_prefix = "    | ",
-                .divider = "  ~~~~~~~\n"
-            };
-        }
-    } else if (max_line_number < 10000) {
-        if (colorize) {
-            error_format = (pm_error_format_t) {
-                .number_prefix = PM_COLOR_GRAY "%4" PRIi32 " | " PM_COLOR_RESET,
-                .blank_prefix = PM_COLOR_GRAY "     | " PM_COLOR_RESET,
-                .divider = PM_COLOR_GRAY "  ~~~~~~~~" PM_COLOR_RESET "\n"
-            };
-        } else {
-            error_format = (pm_error_format_t) {
-                .number_prefix = "%4" PRIi32 " | ",
-                .blank_prefix = "     | ",
-                .divider = "  ~~~~~~~~\n"
-            };
-        }
-    } else {
-        if (colorize) {
-            error_format = (pm_error_format_t) {
-                .number_prefix = PM_COLOR_GRAY "%5" PRIi32 " | " PM_COLOR_RESET,
-                .blank_prefix = PM_COLOR_GRAY "      | " PM_COLOR_RESET,
-                .divider = PM_COLOR_GRAY "  ~~~~~~~~" PM_COLOR_RESET "\n"
-            };
-        } else {
-            error_format = (pm_error_format_t) {
-                .number_prefix = "%5" PRIi32 " | ",
-                .blank_prefix = "      | ",
-                .divider = "  ~~~~~~~~\n"
-            };
-        }
-    }
-
-    error_format.blank_prefix_length = strlen(error_format.blank_prefix);
-    error_format.divider_length = strlen(error_format.divider);
-
-    // Now we're going to iterate through every error in our error list and
-    // display it. While we're iterating, we will display some padding lines of
-    // the source before the error to give some context. We'll be careful not to
-    // display the same line twice in case the errors are close enough in the
-    // source.
-    int32_t last_line = parser->start_line - 1;
-    uint32_t last_column_start = 0;
-    const pm_encoding_t *encoding = parser->encoding;
-
-    for (size_t index = 0; index < error_list->size; index++) {
-        pm_error_t *error = &errors[index];
-
-        // Here we determine how many lines of padding of the source to display,
-        // based on the difference from the last line that was displaid.
-        if (error->line - last_line > 1) {
-            if (error->line - last_line > 2) {
-                if ((index != 0) && (error->line - last_line > 3)) {
-                    pm_buffer_append_string(buffer, error_format.divider, error_format.divider_length);
-                }
-
-                pm_buffer_append_string(buffer, "  ", 2);
-                pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
-            }
-
-            pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
-        }
-
-        // If this is the first error or we're on a new line, then we'll display
-        // the line that has the error in it.
-        if ((index == 0) || (error->line != last_line)) {
-            if (colorize) {
-                pm_buffer_append_string(buffer, PM_COLOR_RED "> " PM_COLOR_RESET, 12);
-            } else {
-                pm_buffer_append_string(buffer, "> ", 2);
-            }
-
-            last_column_start = error->column_start;
-
-            // Find the maximum column end of all the errors on this line.
-            uint32_t column_end = error->column_end;
-            for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
-                if (errors[next_index].line != error->line) break;
-                if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
-            }
-
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
-        }
-
-        const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
-        if (start == parser->end) pm_buffer_append_byte(buffer, '\n');
-
-        // Now we'll display the actual error message. We'll do this by first
-        // putting the prefix to the line, then a bunch of blank spaces
-        // depending on the column, then as many carets as we need to display
-        // the width of the error, then the error message itself.
-        //
-        // Note that this doesn't take into account the width of the actual
-        // character when displaid in the terminal. For some east-asian
-        // languages or emoji, this means it can be thrown off pretty badly. We
-        // will need to solve this eventually.
-        pm_buffer_append_string(buffer, "  ", 2);
-        pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
-
-        size_t column = 0;
-        if (last_column_start >= PM_ERROR_TRUNCATE) {
-            pm_buffer_append_string(buffer, "    ", 4);
-            column = last_column_start;
-        }
-
-        while (column < error->column_start) {
-            pm_buffer_append_byte(buffer, ' ');
-
-            size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
-            column += (char_width == 0 ? 1 : char_width);
-        }
-
-        if (colorize) pm_buffer_append_string(buffer, PM_COLOR_RED, 7);
-        pm_buffer_append_byte(buffer, '^');
-
-        size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
-        column += (char_width == 0 ? 1 : char_width);
-
-        while (column < error->column_end) {
-            pm_buffer_append_byte(buffer, '~');
-
-            size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
-            column += (char_width == 0 ? 1 : char_width);
-        }
-
-        if (colorize) pm_buffer_append_string(buffer, PM_COLOR_RESET, 3);
-
-        if (inline_messages) {
-            pm_buffer_append_byte(buffer, ' ');
-            assert(error->error != NULL);
-
-            const char *message = error->error->message;
-            pm_buffer_append_string(buffer, message, strlen(message));
-        }
-
-        pm_buffer_append_byte(buffer, '\n');
-
-        // Here we determine how many lines of padding to display after the
-        // error, depending on where the next error is in source.
-        last_line = error->line;
-        int32_t next_line = (index == error_list->size - 1) ? (((int32_t) newline_list->size) + parser->start_line) : errors[index + 1].line;
-
-        if (next_line - last_line > 1) {
-            pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
-        }
-
-        if (next_line - last_line > 1) {
-            pm_buffer_append_string(buffer, "  ", 2);
-            pm_parser_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
-        }
-    }
-
-    // Finally, we'll free the array of errors that we allocated.
-    xfree(errors);
-}
-
-#undef PM_ERROR_TRUNCATE
-#undef PM_COLOR_GRAY
-#undef PM_COLOR_RED
-#undef PM_COLOR_RESET
diff --git a/prism/prism.h b/prism/prism.h
index 59067c3021a70a..755c38fca29248 100644
--- a/prism/prism.h
+++ b/prism/prism.h
@@ -219,17 +219,6 @@ PRISM_EXPORTED_FUNCTION const char * pm_token_type_name(pm_token_type_t token_ty
  */
 const char * pm_token_type_human(pm_token_type_t token_type);
 
-/**
- * Format the errors on the parser into the given buffer.
- *
- * @param parser The parser to format the errors for.
- * @param error_list The list of errors to format.
- * @param buffer The buffer to format the errors into.
- * @param colorize Whether or not to colorize the errors with ANSI escape sequences.
- * @param inline_messages Whether or not to inline the messages with the source.
- */
-PRISM_EXPORTED_FUNCTION void pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, bool colorize, bool inline_messages);
-
 // We optionally support dumping to JSON. For systems that don't want or need
 // this functionality, it can be turned off with the PRISM_EXCLUDE_JSON define.
 #ifndef PRISM_EXCLUDE_JSON
diff --git a/test/prism/format_errors_test.rb b/test/prism/format_errors_test.rb
deleted file mode 100644
index 63206d5765c775..00000000000000
--- a/test/prism/format_errors_test.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-return if Prism::BACKEND == :FFI
-
-module Prism
-  class FormatErrorsTest < TestCase
-    def test_basic
-      expected = <<~ERROR
-        > 1 | <>
-            | ^ unexpected '<', ignoring it
-            |  ^ unexpected '>', ignoring it
-      ERROR
-
-      assert_equal expected, Debug.format_errors("<>", false)
-    end
-
-    def test_multiple
-      expected = <<~ERROR
-        > 1 | "%W"\\u"
-            |     ^ unexpected backslash, ignoring it
-            |      ^ unexpected local variable or method, expecting end-of-input
-            |        ^ unterminated string meets end of file
-      ERROR
-
-      assert_equal expected, Debug.format_errors('"%W"\u"', false)
-    end
-
-    def test_truncate_start
-      expected = <<~ERROR
-        > 1 | ... <>
-            |     ^ unexpected '<', ignoring it
-            |      ^ unexpected '>', ignoring it
-      ERROR
-
-      assert_equal expected, Debug.format_errors("#{" " * 30}<>", false)
-    end
-
-    def test_truncate_end
-      expected = <<~ERROR
-        > 1 | <#{" " * 30} ...
-            | ^ unexpected '<', ignoring it
-      ERROR
-
-      assert_equal expected, Debug.format_errors("<#{" " * 30}a", false)
-    end
-
-    def test_truncate_both
-      expected = <<~ERROR
-        > 1 | ... <#{" " * 30} ...
-            |     ^ unexpected '<', ignoring it
-      ERROR
-
-      assert_equal expected, Debug.format_errors("#{" " * 30}<#{" " * 30}a", false)
-    end
-  end
-end
diff --git a/test/prism/newline_test.rb b/test/prism/newline_test.rb
index 96374ce6a70283..cc7f21aec7e59b 100644
--- a/test/prism/newline_test.rb
+++ b/test/prism/newline_test.rb
@@ -10,7 +10,6 @@ class NewlineTest < TestCase
     filepaths = Dir["*.rb", base: base] - %w[
       encoding_test.rb
       errors_test.rb
-      format_errors_test.rb
       parser_test.rb
       regexp_test.rb
       static_literals_test.rb

From 745a948b6d773c3146647ba89539ae32634283b0 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 12:43:42 -0400
Subject: [PATCH 188/242] [ruby/prism] Remove dynamic Debug module methods

https://github.com/ruby/prism/commit/b850794db9
---
 lib/prism/debug.rb |  43 ---------------
 prism/extension.c  | 133 +--------------------------------------------
 2 files changed, 2 insertions(+), 174 deletions(-)

diff --git a/lib/prism/debug.rb b/lib/prism/debug.rb
index 74f824faa70d4f..6380e628be6567 100644
--- a/lib/prism/debug.rb
+++ b/lib/prism/debug.rb
@@ -202,48 +202,5 @@ def self.prism_locals(source)
     def self.newlines(source)
       Prism.parse(source).source.offsets
     end
-
-    # A wrapping around prism's internal encoding data structures. This is used
-    # for reflection and debugging purposes.
-    class Encoding
-      # The name of the encoding, that can be passed to Encoding.find.
-      attr_reader :name
-
-      # Initialize a new encoding with the given name and whether or not it is
-      # a multibyte encoding.
-      def initialize(name, multibyte)
-        @name = name
-        @multibyte = multibyte
-      end
-
-      # Whether or not the encoding is a multibyte encoding.
-      def multibyte?
-        @multibyte
-      end
-
-      # Returns the number of bytes of the first character in the source string,
-      # if it is valid for the encoding. Otherwise, returns 0.
-      def width(source)
-        Encoding._width(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # alphanumeric character for the encoding.
-      def alnum?(source)
-        Encoding._alnum?(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # alphabetic character for the encoding.
-      def alpha?(source)
-        Encoding._alpha?(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # uppercase character for the encoding.
-      def upper?(source)
-        Encoding._upper?(name, source)
-      end
-    end
   end
 end
diff --git a/prism/extension.c b/prism/extension.c
index a0a044f8fb27ca..f692ea616cc80e 100644
--- a/prism/extension.c
+++ b/prism/extension.c
@@ -52,7 +52,7 @@ check_string(VALUE value) {
 
     // Check if the value is a string. If it's not, then raise a type error.
     if (!RB_TYPE_P(value, T_STRING)) {
-        rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected String)", rb_obj_class(value));
+        rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(value));
     }
 
     // Otherwise, return the value as a C string.
@@ -66,7 +66,7 @@ static void
 input_load_string(pm_string_t *input, VALUE string) {
     // Check if the string is a string. If it's not, then raise a type error.
     if (!RB_TYPE_P(string, T_STRING)) {
-        rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected String)", rb_obj_class(string));
+        rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(string));
     }
 
     pm_string_constant_init(input, RSTRING_PTR(string), RSTRING_LEN(string));
@@ -1089,118 +1089,6 @@ parse_file_failure_p(int argc, VALUE *argv, VALUE self) {
     return RTEST(parse_file_success_p(argc, argv, self)) ? Qfalse : Qtrue;
 }
 
-/******************************************************************************/
-/* Utility functions exposed to make testing easier                           */
-/******************************************************************************/
-
-#ifndef PRISM_EXCLUDE_PRETTYPRINT
-
-/**
- * call-seq:
- *   Debug::inspect_node(source) -> inspected
- *
- * Inspect the AST that represents the given source using the prism pretty print
- * as opposed to the Ruby implementation.
- */
-static VALUE
-inspect_node(VALUE self, VALUE source) {
-    pm_string_t input;
-    input_load_string(&input, source);
-
-    pm_parser_t parser;
-    pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), NULL);
-
-    pm_node_t *node = pm_parse(&parser);
-    pm_buffer_t buffer = { 0 };
-
-    pm_prettyprint(&buffer, &parser, node);
-
-    rb_encoding *encoding = rb_enc_find(parser.encoding->name);
-    VALUE string = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), encoding);
-
-    pm_buffer_free(&buffer);
-    pm_node_destroy(&parser, node);
-    pm_parser_free(&parser);
-
-    return string;
-}
-
-#endif
-
-/**
- * call-seq: Debug::Encoding.all -> Array[Debug::Encoding]
- *
- * Return an array of all of the encodings that prism knows about.
- */
-static VALUE
-encoding_all(VALUE self) {
-    VALUE encodings = rb_ary_new();
-
-    for (size_t index = 0; index < PM_ENCODING_MAXIMUM; index++) {
-        const pm_encoding_t *encoding = &pm_encodings[index];
-
-        VALUE encoding_argv[] = { rb_str_new_cstr(encoding->name), encoding->multibyte ? Qtrue : Qfalse };
-        rb_ary_push(encodings, rb_class_new_instance(2, encoding_argv, rb_cPrismDebugEncoding));
-    }
-
-    return encodings;
-}
-
-static const pm_encoding_t *
-encoding_find(VALUE name) {
-    const uint8_t *source = (const uint8_t *) RSTRING_PTR(name);
-    size_t length = RSTRING_LEN(name);
-
-    const pm_encoding_t *encoding = pm_encoding_find(source, source + length);
-    if (encoding == NULL) { rb_raise(rb_eArgError, "Unknown encoding: %s", source); }
-
-    return encoding;
-}
-
-/**
- * call-seq: Debug::Encoding.width(source) -> Integer
- *
- * Returns the width of the first character in the given string if it is valid
- * in the encoding. If it is not, this function returns 0.
- */
-static VALUE
-encoding_char_width(VALUE self, VALUE name, VALUE value) {
-    return ULONG2NUM(encoding_find(name)->char_width((const uint8_t *) RSTRING_PTR(value), RSTRING_LEN(value)));
-}
-
-/**
- * call-seq: Debug::Encoding.alnum?(source) -> true | false
- *
- * Returns true if the first character in the given string is an alphanumeric
- * character in the encoding.
- */
-static VALUE
-encoding_alnum_char(VALUE self, VALUE name, VALUE value) {
-    return encoding_find(name)->alnum_char((const uint8_t *) RSTRING_PTR(value), RSTRING_LEN(value)) > 0 ? Qtrue : Qfalse;
-}
-
-/**
- * call-seq: Debug::Encoding.alpha?(source) -> true | false
- *
- * Returns true if the first character in the given string is an alphabetic
- * character in the encoding.
- */
-static VALUE
-encoding_alpha_char(VALUE self, VALUE name, VALUE value) {
-    return encoding_find(name)->alpha_char((const uint8_t *) RSTRING_PTR(value), RSTRING_LEN(value)) > 0 ? Qtrue : Qfalse;
-}
-
-/**
- * call-seq: Debug::Encoding.upper?(source) -> true | false
- *
- * Returns true if the first character in the given string is an uppercase
- * character in the encoding.
- */
-static VALUE
-encoding_isupper_char(VALUE self, VALUE name, VALUE value) {
-    return encoding_find(name)->isupper_char((const uint8_t *) RSTRING_PTR(value), RSTRING_LEN(value)) ? Qtrue : Qfalse;
-}
-
 /******************************************************************************/
 /* Initialization of the extension                                            */
 /******************************************************************************/
@@ -1276,23 +1164,6 @@ Init_prism(void) {
     rb_define_singleton_method(rb_cPrism, "dump_file", dump_file, -1);
 #endif
 
-    // Next, the functions that will be called by the parser to perform various
-    // internal tasks. We expose these to make them easier to test.
-    VALUE rb_cPrismDebug = rb_define_module_under(rb_cPrism, "Debug");
-
-#ifndef PRISM_EXCLUDE_PRETTYPRINT
-    rb_define_singleton_method(rb_cPrismDebug, "inspect_node", inspect_node, 1);
-#endif
-
-    // Next, define the functions that are exposed through the private
-    // Debug::Encoding class.
-    rb_cPrismDebugEncoding = rb_define_class_under(rb_cPrismDebug, "Encoding", rb_cObject);
-    rb_define_singleton_method(rb_cPrismDebugEncoding, "all", encoding_all, 0);
-    rb_define_singleton_method(rb_cPrismDebugEncoding, "_width", encoding_char_width, 2);
-    rb_define_singleton_method(rb_cPrismDebugEncoding, "_alnum?", encoding_alnum_char, 2);
-    rb_define_singleton_method(rb_cPrismDebugEncoding, "_alpha?", encoding_alpha_char, 2);
-    rb_define_singleton_method(rb_cPrismDebugEncoding, "_upper?", encoding_isupper_char, 2);
-
     // Next, initialize the other APIs.
     Init_prism_api_node();
     Init_prism_pack();

From f8b750370e1fc3b08d152794e39d389d9586fabe Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 12:48:41 -0400
Subject: [PATCH 189/242] [ruby/prism] Remove Debug module

https://github.com/ruby/prism/commit/4d8929ff6a
---
 lib/prism.rb                |   2 -
 lib/prism/debug.rb          | 206 ------------------------------------
 lib/prism/ffi.rb            |   2 +-
 lib/prism/prism.gemspec     |   1 -
 test/prism/comments_test.rb |   2 +-
 test/prism/locals_test.rb   | 185 +++++++++++++++++++++++++++++++-
 test/prism/newline_test.rb  |   1 +
 test/prism/parse_test.rb    |   2 +-
 8 files changed, 187 insertions(+), 214 deletions(-)
 delete mode 100644 lib/prism/debug.rb

diff --git a/lib/prism.rb b/lib/prism.rb
index 2bb7f79bf644d0..66a64e7fd0369e 100644
--- a/lib/prism.rb
+++ b/lib/prism.rb
@@ -13,7 +13,6 @@ module Prism
 
   autoload :BasicVisitor, "prism/visitor"
   autoload :Compiler, "prism/compiler"
-  autoload :Debug, "prism/debug"
   autoload :DesugarCompiler, "prism/desugar_compiler"
   autoload :Dispatcher, "prism/dispatcher"
   autoload :DotVisitor, "prism/dot_visitor"
@@ -32,7 +31,6 @@ module Prism
   # Some of these constants are not meant to be exposed, so marking them as
   # private here.
 
-  private_constant :Debug
   private_constant :LexCompat
   private_constant :LexRipper
 
diff --git a/lib/prism/debug.rb b/lib/prism/debug.rb
deleted file mode 100644
index 6380e628be6567..00000000000000
--- a/lib/prism/debug.rb
+++ /dev/null
@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-module Prism
-  # This module is used for testing and debugging and is not meant to be used by
-  # consumers of this library.
-  module Debug
-    # A wrapper around a RubyVM::InstructionSequence that provides a more
-    # convenient interface for accessing parts of the iseq.
-    class ISeq # :nodoc:
-      attr_reader :parts
-
-      def initialize(parts)
-        @parts = parts
-      end
-
-      def type
-        parts[0]
-      end
-
-      def local_table
-        parts[10]
-      end
-
-      def instructions
-        parts[13]
-      end
-
-      def each_child
-        instructions.each do |instruction|
-          # Only look at arrays. Other instructions are line numbers or
-          # tracepoint events.
-          next unless instruction.is_a?(Array)
-
-          instruction.each do |opnd|
-            # Only look at arrays. Other operands are literals.
-            next unless opnd.is_a?(Array)
-
-            # Only look at instruction sequences. Other operands are literals.
-            next unless opnd[0] == "YARVInstructionSequence/SimpleDataFormat"
-
-            yield ISeq.new(opnd)
-          end
-        end
-      end
-    end
-
-    private_constant :ISeq
-
-    # :call-seq:
-    #   Debug::cruby_locals(source) -> Array
-    #
-    # For the given source, compiles with CRuby and returns a list of all of the
-    # sets of local variables that were encountered.
-    def self.cruby_locals(source)
-      verbose, $VERBOSE = $VERBOSE, nil
-
-      begin
-        locals = [] #: Array[Array[Symbol | Integer]]
-        stack = [ISeq.new(RubyVM::InstructionSequence.compile(source).to_a)]
-
-        while (iseq = stack.pop)
-          names = [*iseq.local_table]
-          names.map!.with_index do |name, index|
-            # When an anonymous local variable is present in the iseq's local
-            # table, it is represented as the stack offset from the top.
-            # However, when these are dumped to binary and read back in, they
-            # are replaced with the symbol :#arg_rest. To consistently handle
-            # this, we replace them here with their index.
-            if name == :"#arg_rest"
-              names.length - index + 1
-            else
-              name
-            end
-          end
-
-          locals << names
-          iseq.each_child { |child| stack << child }
-        end
-
-        locals
-      ensure
-        $VERBOSE = verbose
-      end
-    end
-
-    # Used to hold the place of a local that will be in the local table but
-    # cannot be accessed directly from the source code. For example, the
-    # iteration variable in a for loop or the positional parameter on a method
-    # definition that is destructured.
-    AnonymousLocal = Object.new
-    private_constant :AnonymousLocal
-
-    # :call-seq:
-    #   Debug::prism_locals(source) -> Array
-    #
-    # For the given source, parses with prism and returns a list of all of the
-    # sets of local variables that were encountered.
-    def self.prism_locals(source)
-      locals = [] #: Array[Array[Symbol | Integer]]
-      stack = [Prism.parse(source).value] #: Array[Prism::node]
-
-      while (node = stack.pop)
-        case node
-        when BlockNode, DefNode, LambdaNode
-          names = node.locals
-          params =
-            if node.is_a?(DefNode)
-              node.parameters
-            elsif node.parameters.is_a?(NumberedParametersNode)
-              nil
-            else
-              node.parameters&.parameters
-            end
-
-          # prism places parameters in the same order that they appear in the
-          # source. CRuby places them in the order that they need to appear
-          # according to their own internal calling convention. We mimic that
-          # order here so that we can compare properly.
-          if params
-            sorted = [
-              *params.requireds.map do |required|
-                if required.is_a?(RequiredParameterNode)
-                  required.name
-                else
-                  AnonymousLocal
-                end
-              end,
-              *params.optionals.map(&:name),
-              *((params.rest.name || :*) if params.rest && !params.rest.is_a?(ImplicitRestNode)),
-              *params.posts.map do |post|
-                if post.is_a?(RequiredParameterNode)
-                  post.name
-                else
-                  AnonymousLocal
-                end
-              end,
-              *params.keywords.grep(RequiredKeywordParameterNode).map(&:name),
-              *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
-            ]
-
-            sorted << AnonymousLocal if params.keywords.any?
-
-            if params.keyword_rest.is_a?(ForwardingParameterNode)
-              sorted.push(:*, :**, :&, :"...")
-            elsif params.keyword_rest.is_a?(KeywordRestParameterNode)
-              sorted << (params.keyword_rest.name || :**)
-            end
-
-            # Recurse down the parameter tree to find any destructured
-            # parameters and add them after the other parameters.
-            param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
-            while (param = param_stack.pop)
-              case param
-              when MultiTargetNode
-                param_stack.concat(param.rights.reverse)
-                param_stack << param.rest if param.rest&.expression && !sorted.include?(param.rest.expression.name)
-                param_stack.concat(param.lefts.reverse)
-              when RequiredParameterNode
-                sorted << param.name
-              when SplatNode
-                sorted << param.expression.name
-              end
-            end
-
-            if params.block
-              sorted << (params.block.name || :&)
-            end
-
-            names = sorted.concat(names - sorted)
-          end
-
-          names.map!.with_index do |name, index|
-            if name == AnonymousLocal
-              names.length - index + 1
-            else
-              name
-            end
-          end
-
-          locals << names
-        when ClassNode, ModuleNode, ProgramNode, SingletonClassNode
-          locals << node.locals
-        when ForNode
-          locals << [2]
-        when PostExecutionNode
-          locals.push([], [])
-        when InterpolatedRegularExpressionNode
-          locals << [] if node.once?
-        end
-
-        stack.concat(node.compact_child_nodes)
-      end
-
-      locals
-    end
-
-    # :call-seq:
-    #   Debug::newlines(source) -> Array
-    #
-    # For the given source string, return the byte offsets of every newline in
-    # the source.
-    def self.newlines(source)
-      Prism.parse(source).source.offsets
-    end
-  end
-end
diff --git a/lib/prism/ffi.rb b/lib/prism/ffi.rb
index b62a59d0376499..df7e183310cb19 100644
--- a/lib/prism/ffi.rb
+++ b/lib/prism/ffi.rb
@@ -394,7 +394,7 @@ def dump_options(options)
 
       template << "L"
       if (encoding = options[:encoding])
-        name = encoding.name
+        name = encoding.is_a?(Encoding) ? encoding.name : encoding
         values.push(name.bytesize, name.b)
         template << "A*"
       else
diff --git a/lib/prism/prism.gemspec b/lib/prism/prism.gemspec
index 374591bb70731f..b4504dbf4bb115 100644
--- a/lib/prism/prism.gemspec
+++ b/lib/prism/prism.gemspec
@@ -70,7 +70,6 @@ Gem::Specification.new do |spec|
     "include/prism/version.h",
     "lib/prism.rb",
     "lib/prism/compiler.rb",
-    "lib/prism/debug.rb",
     "lib/prism/desugar_compiler.rb",
     "lib/prism/dispatcher.rb",
     "lib/prism/dot_visitor.rb",
diff --git a/test/prism/comments_test.rb b/test/prism/comments_test.rb
index b99c00268c31ae..952d03239c3873 100644
--- a/test/prism/comments_test.rb
+++ b/test/prism/comments_test.rb
@@ -6,7 +6,7 @@ module Prism
   class CommentsTest < TestCase
     def test_comment_inline
       source = "# comment"
-      assert_equal [0], Debug.newlines(source)
+      assert_equal [0], Prism.parse(source).source.offsets
 
       assert_comment(
         source,
diff --git a/test/prism/locals_test.rb b/test/prism/locals_test.rb
index 0eb73f1b9c76b0..0e57a9a80c9b3f 100644
--- a/test/prism/locals_test.rb
+++ b/test/prism/locals_test.rb
@@ -41,8 +41,8 @@ def teardown
     def assert_locals(filepath)
       source = File.read(filepath)
 
-      expected = Debug.cruby_locals(source)
-      actual = Debug.prism_locals(source)
+      expected = cruby_locals(source)
+      actual = prism_locals(source)
 
       assert_equal(expected, actual)
     end
@@ -54,5 +54,186 @@ def ignore_warnings
     ensure
       $VERBOSE = previous_verbosity
     end
+
+    # A wrapper around a RubyVM::InstructionSequence that provides a more
+    # convenient interface for accessing parts of the iseq.
+    class ISeq
+      attr_reader :parts
+
+      def initialize(parts)
+        @parts = parts
+      end
+
+      def type
+        parts[0]
+      end
+
+      def local_table
+        parts[10]
+      end
+
+      def instructions
+        parts[13]
+      end
+
+      def each_child
+        instructions.each do |instruction|
+          # Only look at arrays. Other instructions are line numbers or
+          # tracepoint events.
+          next unless instruction.is_a?(Array)
+
+          instruction.each do |opnd|
+            # Only look at arrays. Other operands are literals.
+            next unless opnd.is_a?(Array)
+
+            # Only look at instruction sequences. Other operands are literals.
+            next unless opnd[0] == "YARVInstructionSequence/SimpleDataFormat"
+
+            yield ISeq.new(opnd)
+          end
+        end
+      end
+    end
+
+    # Used to hold the place of a local that will be in the local table but
+    # cannot be accessed directly from the source code. For example, the
+    # iteration variable in a for loop or the positional parameter on a method
+    # definition that is destructured.
+    AnonymousLocal = Object.new
+
+    # For the given source, compiles with CRuby and returns a list of all of the
+    # sets of local variables that were encountered.
+    def cruby_locals(source)
+      verbose, $VERBOSE = $VERBOSE, nil
+
+      begin
+        locals = [] #: Array[Array[Symbol | Integer]]
+        stack = [ISeq.new(RubyVM::InstructionSequence.compile(source).to_a)]
+
+        while (iseq = stack.pop)
+          names = [*iseq.local_table]
+          names.map!.with_index do |name, index|
+            # When an anonymous local variable is present in the iseq's local
+            # table, it is represented as the stack offset from the top.
+            # However, when these are dumped to binary and read back in, they
+            # are replaced with the symbol :#arg_rest. To consistently handle
+            # this, we replace them here with their index.
+            if name == :"#arg_rest"
+              names.length - index + 1
+            else
+              name
+            end
+          end
+
+          locals << names
+          iseq.each_child { |child| stack << child }
+        end
+
+        locals
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+
+    # For the given source, parses with prism and returns a list of all of the
+    # sets of local variables that were encountered.
+    def prism_locals(source)
+      locals = [] #: Array[Array[Symbol | Integer]]
+      stack = [Prism.parse(source).value] #: Array[Prism::node]
+
+      while (node = stack.pop)
+        case node
+        when BlockNode, DefNode, LambdaNode
+          names = node.locals
+          params =
+            if node.is_a?(DefNode)
+              node.parameters
+            elsif node.parameters.is_a?(NumberedParametersNode)
+              nil
+            else
+              node.parameters&.parameters
+            end
+
+          # prism places parameters in the same order that they appear in the
+          # source. CRuby places them in the order that they need to appear
+          # according to their own internal calling convention. We mimic that
+          # order here so that we can compare properly.
+          if params
+            sorted = [
+              *params.requireds.map do |required|
+                if required.is_a?(RequiredParameterNode)
+                  required.name
+                else
+                  AnonymousLocal
+                end
+              end,
+              *params.optionals.map(&:name),
+              *((params.rest.name || :*) if params.rest && !params.rest.is_a?(ImplicitRestNode)),
+              *params.posts.map do |post|
+                if post.is_a?(RequiredParameterNode)
+                  post.name
+                else
+                  AnonymousLocal
+                end
+              end,
+              *params.keywords.grep(RequiredKeywordParameterNode).map(&:name),
+              *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
+            ]
+
+            sorted << AnonymousLocal if params.keywords.any?
+
+            if params.keyword_rest.is_a?(ForwardingParameterNode)
+              sorted.push(:*, :**, :&, :"...")
+            elsif params.keyword_rest.is_a?(KeywordRestParameterNode)
+              sorted << (params.keyword_rest.name || :**)
+            end
+
+            # Recurse down the parameter tree to find any destructured
+            # parameters and add them after the other parameters.
+            param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
+            while (param = param_stack.pop)
+              case param
+              when MultiTargetNode
+                param_stack.concat(param.rights.reverse)
+                param_stack << param.rest if param.rest&.expression && !sorted.include?(param.rest.expression.name)
+                param_stack.concat(param.lefts.reverse)
+              when RequiredParameterNode
+                sorted << param.name
+              when SplatNode
+                sorted << param.expression.name
+              end
+            end
+
+            if params.block
+              sorted << (params.block.name || :&)
+            end
+
+            names = sorted.concat(names - sorted)
+          end
+
+          names.map!.with_index do |name, index|
+            if name == AnonymousLocal
+              names.length - index + 1
+            else
+              name
+            end
+          end
+
+          locals << names
+        when ClassNode, ModuleNode, ProgramNode, SingletonClassNode
+          locals << node.locals
+        when ForNode
+          locals << [2]
+        when PostExecutionNode
+          locals.push([], [])
+        when InterpolatedRegularExpressionNode
+          locals << [] if node.once?
+        end
+
+        stack.concat(node.compact_child_nodes)
+      end
+
+      locals
+    end
   end
 end
diff --git a/test/prism/newline_test.rb b/test/prism/newline_test.rb
index cc7f21aec7e59b..75593d34bf133c 100644
--- a/test/prism/newline_test.rb
+++ b/test/prism/newline_test.rb
@@ -10,6 +10,7 @@ class NewlineTest < TestCase
     filepaths = Dir["*.rb", base: base] - %w[
       encoding_test.rb
       errors_test.rb
+      locals_test.rb
       parser_test.rb
       regexp_test.rb
       static_literals_test.rb
diff --git a/test/prism/parse_test.rb b/test/prism/parse_test.rb
index afb53e06685c11..5c66caebb96e87 100644
--- a/test/prism/parse_test.rb
+++ b/test/prism/parse_test.rb
@@ -265,7 +265,7 @@ def test_parse_file_comments
         # Next, assert that the newlines are in the expected places.
         expected_newlines = [0]
         source.b.scan("\n") { expected_newlines << $~.offset(0)[0] + 1 }
-        assert_equal expected_newlines, Debug.newlines(source)
+        assert_equal expected_newlines, Prism.parse(source).source.offsets
 
         if ripper_should_match
           # Finally, assert that we can lex the source and get the same tokens as

From 9f71393fe47cfd6e063a63c1d5267400cbe44346 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 13:23:25 -0400
Subject: [PATCH 190/242] [ruby/prism] Fix up self-write order for lex

https://github.com/ruby/prism/commit/8f6da451b4
---
 prism/prism.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index 418aa93d2cda54..c30d693d19248b 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -20204,7 +20204,6 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                     return result;
                 }
                 case PM_CALL_NODE: {
-                    parser_lex(parser);
                     pm_call_node_t *cast = (pm_call_node_t *) node;
 
                     // If we have a vcall (a method with no arguments and no
@@ -20215,6 +20214,8 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                         pm_refute_numbered_parameter(parser, message_loc->start, message_loc->end);
 
                         pm_constant_id_t constant_id = pm_parser_local_add_location(parser, message_loc->start, message_loc->end, 1);
+                        parser_lex(parser);
+
                         pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ);
                         pm_node_t *result = (pm_node_t *) pm_local_variable_and_write_node_create(parser, (pm_node_t *) cast, &token, value, constant_id, 0);
 
@@ -20222,6 +20223,10 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                         return result;
                     }
 
+                    // Move past the token here so that we have already added
+                    // the local variable by this point.
+                    parser_lex(parser);
+
                     // If there is no call operator and the message is "[]" then
                     // this is an aref expression, and we can transform it into
                     // an aset expression.
@@ -20317,7 +20322,6 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                     return result;
                 }
                 case PM_CALL_NODE: {
-                    parser_lex(parser);
                     pm_call_node_t *cast = (pm_call_node_t *) node;
 
                     // If we have a vcall (a method with no arguments and no
@@ -20328,6 +20332,8 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                         pm_refute_numbered_parameter(parser, message_loc->start, message_loc->end);
 
                         pm_constant_id_t constant_id = pm_parser_local_add_location(parser, message_loc->start, message_loc->end, 1);
+                        parser_lex(parser);
+
                         pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ);
                         pm_node_t *result = (pm_node_t *) pm_local_variable_or_write_node_create(parser, (pm_node_t *) cast, &token, value, constant_id, 0);
 
@@ -20335,6 +20341,10 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                         return result;
                     }
 
+                    // Move past the token here so that we have already added
+                    // the local variable by this point.
+                    parser_lex(parser);
+
                     // If there is no call operator and the message is "[]" then
                     // this is an aref expression, and we can transform it into
                     // an aset expression.

From c7281e2d671cd57378630ce0f2a2db97fb12e365 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Fri, 24 May 2024 15:20:50 -0400
Subject: [PATCH 191/242] [ruby/prism] Fix up ruby_parser string concat

https://github.com/ruby/prism/commit/4b06eae0df
---
 lib/prism/translation/ruby_parser.rb | 2 ++
 test/prism/ruby_parser_test.rb       | 3 ---
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/prism/translation/ruby_parser.rb b/lib/prism/translation/ruby_parser.rb
index fe08a493d6f29d..ec458a3b639666 100644
--- a/lib/prism/translation/ruby_parser.rb
+++ b/lib/prism/translation/ruby_parser.rb
@@ -875,6 +875,8 @@ def visit_interpolated_x_string_node(node)
               else
                 visited << result
               end
+            elsif result[0] == :dstr
+              visited.concat(result[1..-1])
             else
               visited << result
             end
diff --git a/test/prism/ruby_parser_test.rb b/test/prism/ruby_parser_test.rb
index b4afff078220dc..0fd96d42b51573 100644
--- a/test/prism/ruby_parser_test.rb
+++ b/test/prism/ruby_parser_test.rb
@@ -34,18 +34,15 @@ class RubyParserTest < TestCase
       seattlerb/masgn_colon3.txt
       seattlerb/messy_op_asgn_lineno.txt
       seattlerb/op_asgn_primary_colon_const_command_call.txt
-      seattlerb/parse_line_evstr_after_break.txt
       seattlerb/regexp_esc_C_slash.txt
       seattlerb/str_lit_concat_bad_encodings.txt
       unescaping.txt
       unparser/corpus/literal/kwbegin.txt
       unparser/corpus/literal/send.txt
-      unparser/corpus/semantic/dstr.txt
       whitequark/masgn_const.txt
       whitequark/ruby_bug_12402.txt
       whitequark/ruby_bug_14690.txt
       whitequark/space_args_block.txt
-      whitequark/string_concat.txt
     ]
 
     # https://github.com/seattlerb/ruby_parser/issues/344

From 4d0c5486a2773f0474a51033d4f685e5c766ec30 Mon Sep 17 00:00:00 2001
From: Jacklyn Ma <29336370+jacklynhma@users.noreply.github.com>
Date: Wed, 8 May 2024 12:45:16 -0400
Subject: [PATCH 192/242] [rubygems/rubygems] update cache checksums to
 decrease string allocations

https://github.com/rubygems/rubygems/commit/85371a961a
---
 lib/bundler/compact_index_client/cache.rb | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/lib/bundler/compact_index_client/cache.rb b/lib/bundler/compact_index_client/cache.rb
index 55911fdecf897b..bc6abaebc773c3 100644
--- a/lib/bundler/compact_index_client/cache.rb
+++ b/lib/bundler/compact_index_client/cache.rb
@@ -55,14 +55,9 @@ def versions_etag_path
       end
 
       def checksums
-        checksums = {}
-
-        lines(versions_path).each do |line|
-          name, _, checksum = line.split(" ", 3)
-          checksums[name] = checksum
+        lines(versions_path).each_with_object({}) do |line, checksums|
+          parse_version_checksum(line, checksums)
         end
-
-        checksums
       end
 
       def dependencies(name)
@@ -106,6 +101,20 @@ def parse_gem(line)
         @dependency_parser.parse(line)
       end
 
+      # This is mostly the same as `split(" ", 3)` but it avoids allocating extra objects.
+      # This method gets called at least once for every gem when parsing versions.
+      def parse_version_checksum(line, checksums)
+        line.freeze # allows slicing into the string to not allocate a copy of the line
+        name_end = line.index(" ")
+        checksum_start = line.index(" ", name_end + 1) + 1
+        checksum_end = line.size - checksum_start
+        # freeze name since it is used as a hash key
+        # pre-freezing means a frozen copy isn't created
+        name = line[0, name_end].freeze
+        checksum = line[checksum_start, checksum_end]
+        checksums[name] = checksum
+      end
+
       def info_roots
         [
           directory.join("info"),

From 0bae2f00025b6b51a9e0c9e3348d5f5d16c2aae4 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sat, 25 May 2024 19:15:25 +0900
Subject: [PATCH 193/242] [Bug #20510] Do not count optional hash argument for
 `IO.new`

Since `IO.new` accepts one or two positional arguments except for the
optional hash argument, exclude the optional hash argument from the
check for delegation to `IO.new`.
---
 io.c                   | 56 +++++++++++++++++-------------------------
 test/ruby/test_file.rb | 33 +++++++++++++++++++++++++
 test/ruby/test_io.rb   |  9 +++++++
 3 files changed, 64 insertions(+), 34 deletions(-)

diff --git a/io.c b/io.c
index feff4459437cca..9ef289285427f5 100644
--- a/io.c
+++ b/io.c
@@ -8026,37 +8026,18 @@ ruby_popen_writer(char *const *argv, rb_pid_t *pid)
     return NULL;
 }
 
-static void
-rb_scan_open_args(int argc, const VALUE *argv,
-        VALUE *fname_p, int *oflags_p, int *fmode_p,
-        struct rb_io_encoding *convconfig_p, mode_t *perm_p)
+static VALUE
+rb_open_file(VALUE io, VALUE fname, VALUE vmode, VALUE vperm, VALUE opt)
 {
-    VALUE opt, fname, vmode, vperm;
+    struct rb_io_encoding convconfig;
     int oflags, fmode;
     mode_t perm;
 
-    argc = rb_scan_args(argc, argv, "12:", &fname, &vmode, &vperm, &opt);
     FilePathValue(fname);
 
-    rb_io_extract_modeenc(&vmode, &vperm, opt, &oflags, &fmode, convconfig_p);
-
-    perm = NIL_P(vperm) ? 0666 :  NUM2MODET(vperm);
-
-    *fname_p = fname;
-    *oflags_p = oflags;
-    *fmode_p = fmode;
-    *perm_p = perm;
-}
-
-static VALUE
-rb_open_file(int argc, const VALUE *argv, VALUE io)
-{
-    VALUE fname;
-    int oflags, fmode;
-    struct rb_io_encoding convconfig;
-    mode_t perm;
+    rb_io_extract_modeenc(&vmode, &vperm, opt, &oflags, &fmode, &convconfig);
+    perm = NIL_P(vperm) ? 0666 : NUM2MODET(vperm);
 
-    rb_scan_open_args(argc, argv, &fname, &oflags, &fmode, &convconfig, &perm);
     rb_file_open_generic(io, fname, oflags, fmode, &convconfig, perm);
 
     return io;
@@ -9379,6 +9360,8 @@ rb_io_make_open_file(VALUE obj)
     return fp;
 }
 
+static VALUE io_initialize(VALUE io, VALUE fnum, VALUE vmode, VALUE opt);
+
 /*
  *  call-seq:
  *    IO.new(fd, mode = 'r', **opts) -> io
@@ -9424,18 +9407,24 @@ static VALUE
 rb_io_initialize(int argc, VALUE *argv, VALUE io)
 {
     VALUE fnum, vmode;
+    VALUE opt;
+
+    rb_scan_args(argc, argv, "11:", &fnum, &vmode, &opt);
+    return io_initialize(io, fnum, vmode, opt);
+}
+
+static VALUE
+io_initialize(VALUE io, VALUE fnum, VALUE vmode, VALUE opt)
+{
     rb_io_t *fp;
     int fd, fmode, oflags = O_RDONLY;
     struct rb_io_encoding convconfig;
-    VALUE opt;
 #if defined(HAVE_FCNTL) && defined(F_GETFL)
     int ofmode;
 #else
     struct stat st;
 #endif
 
-
-    argc = rb_scan_args(argc, argv, "11:", &fnum, &vmode, &opt);
     rb_io_extract_modeenc(&vmode, 0, opt, &oflags, &fmode, &convconfig);
 
     fd = NUM2INT(fnum);
@@ -9584,17 +9573,16 @@ rb_file_initialize(int argc, VALUE *argv, VALUE io)
     if (RFILE(io)->fptr) {
         rb_raise(rb_eRuntimeError, "reinitializing File");
     }
-    if (0 < argc && argc < 3) {
-        VALUE fd = rb_check_to_int(argv[0]);
+    VALUE fname, vmode, vperm, opt;
+    int posargc = rb_scan_args(argc, argv, "12:", &fname, &vmode, &vperm, &opt);
+    if (posargc < 3) {          /* perm is File only */
+        VALUE fd = rb_check_to_int(fname);
 
         if (!NIL_P(fd)) {
-            argv[0] = fd;
-            return rb_io_initialize(argc, argv, io);
+            return io_initialize(io, fd, vmode, opt);
         }
     }
-    rb_open_file(argc, argv, io);
-
-    return io;
+    return rb_open_file(io, fname, vmode, vperm, opt);
 }
 
 /* :nodoc: */
diff --git a/test/ruby/test_file.rb b/test/ruby/test_file.rb
index aa10566bfa73a1..9fa96f8a7c28a5 100644
--- a/test/ruby/test_file.rb
+++ b/test/ruby/test_file.rb
@@ -460,6 +460,39 @@ def test_long_unc
     end
   end
 
+  def test_initialize
+    Dir.mktmpdir(__method__.to_s) do |tmpdir|
+      path = File.join(tmpdir, "foo")
+
+      assert_raise(Errno::ENOENT) {File.new(path)}
+      f = File.new(path, "w")
+      f.write("FOO\n")
+      f.close
+      f = File.new(path)
+      data = f.read
+      f.close
+      assert_equal("FOO\n", data)
+
+      f = File.new(path, File::WRONLY)
+      f.write("BAR\n")
+      f.close
+      f = File.new(path, File::RDONLY)
+      data = f.read
+      f.close
+      assert_equal("BAR\n", data)
+
+      data = File.open(path) {|file|
+        File.new(file.fileno, mode: File::RDONLY, autoclose: false).read
+      }
+      assert_equal("BAR\n", data)
+
+      data = File.open(path) {|file|
+        File.new(file.fileno, File::RDONLY, autoclose: false).read
+      }
+      assert_equal("BAR\n", data)
+    end
+  end
+
   def test_file_open_newline_option
     Dir.mktmpdir(__method__.to_s) do |tmpdir|
       path = File.join(tmpdir, "foo")
diff --git a/test/ruby/test_io.rb b/test/ruby/test_io.rb
index 476d9f882fc579..ce81286c4d328e 100644
--- a/test/ruby/test_io.rb
+++ b/test/ruby/test_io.rb
@@ -2929,6 +2929,15 @@ def test_initialize
       f.close
 
       assert_equal("FOO\n", File.read(t.path))
+
+      fd = IO.sysopen(t.path)
+      %w[w r+ w+ a+].each do |mode|
+        assert_raise(Errno::EINVAL, "#{mode} [ruby-dev:38571]") {IO.new(fd, mode)}
+      end
+      f = IO.new(fd, "r")
+      data = f.read
+      f.close
+      assert_equal("FOO\n", data)
     }
   end
 

From 6b0afbb111716e7b1fdc711d8afd26c723a9bb0c Mon Sep 17 00:00:00 2001
From: Martin Emde <me@martinemde.com>
Date: Tue, 21 May 2024 21:51:18 -0700
Subject: [PATCH 194/242] [rubygems/rubygems] Reorganize and refactor
 CompactIndexClient

https://github.com/rubygems/rubygems/commit/71bcf354f5
---
 lib/bundler.rb                                |   1 +
 lib/bundler/cli.rb                            |  11 +-
 lib/bundler/compact_index_client.rb           |  78 +++--------
 lib/bundler/compact_index_client/cache.rb     | 128 +++++++-----------
 lib/bundler/compact_index_client/parser.rb    |  84 ++++++++++++
 lib/bundler/fetcher/compact_index.rb          |   4 +-
 .../bundler/fetcher/compact_index_spec.rb     |   6 +-
 7 files changed, 157 insertions(+), 155 deletions(-)
 create mode 100644 lib/bundler/compact_index_client/parser.rb

diff --git a/lib/bundler.rb b/lib/bundler.rb
index 5033109db64a7e..adf0a8e450b661 100644
--- a/lib/bundler.rb
+++ b/lib/bundler.rb
@@ -42,6 +42,7 @@ module Bundler
   autoload :Checksum,               File.expand_path("bundler/checksum", __dir__)
   autoload :CLI,                    File.expand_path("bundler/cli", __dir__)
   autoload :CIDetector,             File.expand_path("bundler/ci_detector", __dir__)
+  autoload :CompactIndexClient,     File.expand_path("bundler/compact_index_client", __dir__)
   autoload :Definition,             File.expand_path("bundler/definition", __dir__)
   autoload :Dependency,             File.expand_path("bundler/dependency", __dir__)
   autoload :Deprecate,              File.expand_path("bundler/deprecate", __dir__)
diff --git a/lib/bundler/cli.rb b/lib/bundler/cli.rb
index 40f19c7fed1da0..eb67668cd2b5bf 100644
--- a/lib/bundler/cli.rb
+++ b/lib/bundler/cli.rb
@@ -767,13 +767,10 @@ def warn_on_outdated_bundler
 
       return unless SharedHelpers.md5_available?
 
-      latest = Fetcher::CompactIndex.
-               new(nil, Source::Rubygems::Remote.new(Gem::URI("https://rubygems.org")), nil, nil).
-               send(:compact_index_client).
-               instance_variable_get(:@cache).
-               dependencies("bundler").
-               map {|d| Gem::Version.new(d.first) }.
-               max
+      require_relative "vendored_uri"
+      remote = Source::Rubygems::Remote.new(Gem::URI("https://rubygems.org"))
+      cache_path = Bundler.user_cache.join("compact_index", remote.cache_slug)
+      latest = Bundler::CompactIndexClient.new(cache_path).latest_version("bundler")
       return unless latest
 
       current = Gem::Version.new(VERSION)
diff --git a/lib/bundler/compact_index_client.rb b/lib/bundler/compact_index_client.rb
index 68e0d7e0d51ffc..2bef0a1afc6242 100644
--- a/lib/bundler/compact_index_client.rb
+++ b/lib/bundler/compact_index_client.rb
@@ -21,24 +21,17 @@ class Error < StandardError; end
 
     require_relative "compact_index_client/cache"
     require_relative "compact_index_client/cache_file"
+    require_relative "compact_index_client/parser"
     require_relative "compact_index_client/updater"
 
-    attr_reader :directory
-
-    def initialize(directory, fetcher)
-      @directory = Pathname.new(directory)
-      @updater = Updater.new(fetcher)
-      @cache = Cache.new(@directory)
-      @endpoints = Set.new
-      @info_checksums_by_name = {}
-      @parsed_checksums = false
-      @mutex = Thread::Mutex.new
+    def initialize(directory, fetcher = nil)
+      @cache = Cache.new(directory, fetcher)
+      @parser = Parser.new(@cache)
     end
 
     def execution_mode=(block)
       Bundler::CompactIndexClient.debug { "execution_mode=" }
-      @endpoints = Set.new
-
+      @cache.reset!
       @execution_mode = block
     end
 
@@ -60,67 +53,28 @@ def sequentially
     end
 
     def names
-      Bundler::CompactIndexClient.debug { "/names" }
-      update("names", @cache.names_path, @cache.names_etag_path)
-      @cache.names
+      Bundler::CompactIndexClient.debug { "names" }
+      @parser.names
     end
 
     def versions
-      Bundler::CompactIndexClient.debug { "/versions" }
-      update("versions", @cache.versions_path, @cache.versions_etag_path)
-      versions, @info_checksums_by_name = @cache.versions
-      versions
+      Bundler::CompactIndexClient.debug { "versions" }
+      @parser.versions
     end
 
     def dependencies(names)
       Bundler::CompactIndexClient.debug { "dependencies(#{names})" }
-      execution_mode.call(names) do |name|
-        update_info(name)
-        @cache.dependencies(name).map {|d| d.unshift(name) }
-      end.flatten(1)
-    end
-
-    def update_and_parse_checksums!
-      Bundler::CompactIndexClient.debug { "update_and_parse_checksums!" }
-      return @info_checksums_by_name if @parsed_checksums
-      update("versions", @cache.versions_path, @cache.versions_etag_path)
-      @info_checksums_by_name = @cache.checksums
-      @parsed_checksums = true
-    end
-
-    private
-
-    def update(remote_path, local_path, local_etag_path)
-      Bundler::CompactIndexClient.debug { "update(#{local_path}, #{remote_path})" }
-      unless synchronize { @endpoints.add?(remote_path) }
-        Bundler::CompactIndexClient.debug { "already fetched #{remote_path}" }
-        return
-      end
-      @updater.update(url(remote_path), local_path, local_etag_path)
-    end
-
-    def update_info(name)
-      Bundler::CompactIndexClient.debug { "update_info(#{name})" }
-      path = @cache.info_path(name)
-      unless existing = @info_checksums_by_name[name]
-        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since it is missing from versions" }
-        return
-      end
-      checksum = SharedHelpers.checksum_for_file(path, :MD5)
-      if checksum == existing
-        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since the versions checksum matches the local checksum" }
-        return
-      end
-      Bundler::CompactIndexClient.debug { "updating info for #{name} since the versions checksum #{existing} != the local checksum #{checksum}" }
-      update("info/#{name}", path, @cache.info_etag_path(name))
+      execution_mode.call(names) {|name| @parser.info(name) }.flatten(1)
     end
 
-    def url(path)
-      path
+    def latest_version(name)
+      Bundler::CompactIndexClient.debug { "latest_version(#{name})" }
+      @parser.info(name).map {|d| Gem::Version.new(d[1]) }.max
     end
 
-    def synchronize
-      @mutex.synchronize { yield }
+    def available?
+      Bundler::CompactIndexClient.debug { "available?" }
+      @parser.available?
     end
   end
 end
diff --git a/lib/bundler/compact_index_client/cache.rb b/lib/bundler/compact_index_client/cache.rb
index bc6abaebc773c3..bedd7f8028a38c 100644
--- a/lib/bundler/compact_index_client/cache.rb
+++ b/lib/bundler/compact_index_client/cache.rb
@@ -7,123 +7,89 @@ class CompactIndexClient
     class Cache
       attr_reader :directory
 
-      def initialize(directory)
+      def initialize(directory, fetcher = nil)
         @directory = Pathname.new(directory).expand_path
-        info_roots.each {|dir| mkdir(dir) }
-        mkdir(info_etag_root)
+        @updater = Updater.new(fetcher) if fetcher
+        @mutex = Thread::Mutex.new
+        @endpoints = Set.new
+
+        @info_root = mkdir("info")
+        @special_characters_info_root = mkdir("info-special-characters")
+        @info_etag_root = mkdir("info-etags")
       end
 
       def names
-        lines(names_path)
+        fetch("names", names_path, names_etag_path)
       end
 
-      def names_path
-        directory.join("names")
+      def versions
+        fetch("versions", versions_path, versions_etag_path)
       end
 
-      def names_etag_path
-        directory.join("names.etag")
-      end
+      def info(name, remote_checksum = nil)
+        path = info_path(name)
 
-      def versions
-        versions_by_name = Hash.new {|hash, key| hash[key] = [] }
-        info_checksums_by_name = {}
-
-        lines(versions_path).each do |line|
-          name, versions_string, info_checksum = line.split(" ", 3)
-          info_checksums_by_name[name] = info_checksum || ""
-          versions_string.split(",") do |version|
-            delete = version.delete_prefix!("-")
-            version = version.split("-", 2).unshift(name)
-            if delete
-              versions_by_name[name].delete(version)
-            else
-              versions_by_name[name] << version
-            end
-          end
+        if remote_checksum && remote_checksum != SharedHelpers.checksum_for_file(path, :MD5)
+          fetch("info/#{name}", path, info_etag_path(name))
+        else
+          Bundler::CompactIndexClient.debug { "update skipped info/#{name} (#{remote_checksum ? "versions index checksum is nil" : "versions index checksum matches local"})" }
+          read(path)
         end
-
-        [versions_by_name, info_checksums_by_name]
-      end
-
-      def versions_path
-        directory.join("versions")
       end
 
-      def versions_etag_path
-        directory.join("versions.etag")
+      def reset!
+        @mutex.synchronize { @endpoints.clear }
       end
 
-      def checksums
-        lines(versions_path).each_with_object({}) do |line, checksums|
-          parse_version_checksum(line, checksums)
-        end
-      end
+      private
 
-      def dependencies(name)
-        lines(info_path(name)).map do |line|
-          parse_gem(line)
-        end
-      end
+      def names_path = directory.join("names")
+      def names_etag_path = directory.join("names.etag")
+      def versions_path = directory.join("versions")
+      def versions_etag_path = directory.join("versions.etag")
 
       def info_path(name)
         name = name.to_s
+        # TODO: converge this into the info_root by hashing all filenames like info_etag_path
         if /[^a-z0-9_-]/.match?(name)
           name += "-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}"
-          info_roots.last.join(name)
+          @special_characters_info_root.join(name)
         else
-          info_roots.first.join(name)
+          @info_root.join(name)
         end
       end
 
       def info_etag_path(name)
         name = name.to_s
-        info_etag_root.join("#{name}-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}")
+        @info_etag_root.join("#{name}-#{SharedHelpers.digest(:MD5).hexdigest(name).downcase}")
       end
 
-      private
-
-      def mkdir(dir)
-        SharedHelpers.filesystem_access(dir) do
-          FileUtils.mkdir_p(dir)
+      def mkdir(name)
+        directory.join(name).tap do |dir|
+          SharedHelpers.filesystem_access(dir) do
+            FileUtils.mkdir_p(dir)
+          end
         end
       end
 
-      def lines(path)
-        return [] unless path.file?
-        lines = SharedHelpers.filesystem_access(path, :read, &:read).split("\n")
-        header = lines.index("---")
-        header ? lines[header + 1..-1] : lines
-      end
-
-      def parse_gem(line)
-        @dependency_parser ||= GemParser.new
-        @dependency_parser.parse(line)
-      end
+      def fetch(remote_path, path, etag_path)
+        if already_fetched?(remote_path)
+          Bundler::CompactIndexClient.debug { "already fetched #{remote_path}" }
+        else
+          Bundler::CompactIndexClient.debug { "fetching #{remote_path}" }
+          @updater&.update(remote_path, path, etag_path)
+        end
 
-      # This is mostly the same as `split(" ", 3)` but it avoids allocating extra objects.
-      # This method gets called at least once for every gem when parsing versions.
-      def parse_version_checksum(line, checksums)
-        line.freeze # allows slicing into the string to not allocate a copy of the line
-        name_end = line.index(" ")
-        checksum_start = line.index(" ", name_end + 1) + 1
-        checksum_end = line.size - checksum_start
-        # freeze name since it is used as a hash key
-        # pre-freezing means a frozen copy isn't created
-        name = line[0, name_end].freeze
-        checksum = line[checksum_start, checksum_end]
-        checksums[name] = checksum
+        read(path)
       end
 
-      def info_roots
-        [
-          directory.join("info"),
-          directory.join("info-special-characters"),
-        ]
+      def already_fetched?(remote_path)
+        @mutex.synchronize { !@endpoints.add?(remote_path) }
       end
 
-      def info_etag_root
-        directory.join("info-etags")
+      def read(path)
+        return unless path.file?
+        SharedHelpers.filesystem_access(path, :read, &:read)
       end
     end
   end
diff --git a/lib/bundler/compact_index_client/parser.rb b/lib/bundler/compact_index_client/parser.rb
new file mode 100644
index 00000000000000..a227bc2cfd8554
--- /dev/null
+++ b/lib/bundler/compact_index_client/parser.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CompactIndexClient
+    class Parser
+      # `compact_index` - an object responding to #names, #versions, #info(name, checksum),
+      #                   returning the file contents as a string
+      def initialize(compact_index)
+        @compact_index = compact_index
+        @info_checksums = nil
+        @versions_by_name = nil
+        @available = nil
+      end
+
+      def names
+        lines(@compact_index.names)
+      end
+
+      def versions
+        @versions_by_name ||= Hash.new {|hash, key| hash[key] = [] }
+        @info_checksums = {}
+
+        lines(@compact_index.versions).each do |line|
+          name, versions_string, checksum = line.split(" ", 3)
+          @info_checksums[name] = checksum || ""
+          versions_string.split(",") do |version|
+            delete = version.delete_prefix!("-")
+            version = version.split("-", 2).unshift(name)
+            if delete
+              @versions_by_name[name].delete(version)
+            else
+              @versions_by_name[name] << version
+            end
+          end
+        end
+
+        @versions_by_name
+      end
+
+      def info(name)
+        data = @compact_index.info(name, info_checksums[name])
+        lines(data).map {|line| gem_parser.parse(line).unshift(name) }
+      end
+
+      def available?
+        return @available unless @available.nil?
+        @available = !info_checksums.empty?
+      end
+
+      private
+
+      def info_checksums
+        @info_checksums ||= lines(@compact_index.versions).each_with_object({}) do |line, checksums|
+          parse_version_checksum(line, checksums)
+        end
+      end
+
+      def lines(data)
+        return [] if data.nil? || data.empty?
+        lines = data.split("\n")
+        header = lines.index("---")
+        header ? lines[header + 1..-1] : lines
+      end
+
+      def gem_parser
+        @gem_parser ||= GemParser.new
+      end
+
+      # This is mostly the same as `split(" ", 3)` but it avoids allocating extra objects.
+      # This method gets called at least once for every gem when parsing versions.
+      def parse_version_checksum(line, checksums)
+        line.freeze # allows slicing into the string to not allocate a copy of the line
+        name_end = line.index(" ")
+        checksum_start = line.index(" ", name_end + 1) + 1
+        checksum_end = line.size - checksum_start
+        # freeze name since it is used as a hash key
+        # pre-freezing means a frozen copy isn't created
+        name = line[0, name_end].freeze
+        checksum = line[checksum_start, checksum_end]
+        checksums[name] = checksum
+      end
+    end
+  end
+end
diff --git a/lib/bundler/fetcher/compact_index.rb b/lib/bundler/fetcher/compact_index.rb
index db914839b1d8fa..b92482d88857d8 100644
--- a/lib/bundler/fetcher/compact_index.rb
+++ b/lib/bundler/fetcher/compact_index.rb
@@ -4,8 +4,6 @@
 require_relative "../worker"
 
 module Bundler
-  autoload :CompactIndexClient, File.expand_path("../compact_index_client", __dir__)
-
   class Fetcher
     class CompactIndex < Base
       def self.compact_index_request(method_name)
@@ -61,7 +59,7 @@ def available?
           return nil
         end
         # Read info file checksums out of /versions, so we can know if gems are up to date
-        compact_index_client.update_and_parse_checksums!
+        compact_index_client.available?
       rescue CompactIndexClient::Updater::MismatchedChecksumError => e
         Bundler.ui.debug(e.message)
         nil
diff --git a/spec/bundler/bundler/fetcher/compact_index_spec.rb b/spec/bundler/bundler/fetcher/compact_index_spec.rb
index a988171f341858..a7bb61a9007aa0 100644
--- a/spec/bundler/bundler/fetcher/compact_index_spec.rb
+++ b/spec/bundler/bundler/fetcher/compact_index_spec.rb
@@ -4,13 +4,15 @@
 require "bundler/compact_index_client"
 
 RSpec.describe Bundler::Fetcher::CompactIndex do
-  let(:downloader)  { double(:downloader) }
+  let(:response) { double(:response) }
+  let(:downloader) { double(:downloader, fetch: response) }
   let(:display_uri) { Gem::URI("http://sampleuri.com") }
   let(:remote)      { double(:remote, cache_slug: "lsjdf", uri: display_uri) }
   let(:gem_remote_fetcher) { nil }
   let(:compact_index) { described_class.new(downloader, remote, display_uri, gem_remote_fetcher) }
 
   before do
+    allow(response).to receive(:is_a?).with(Gem::Net::HTTPNotModified).and_return(true)
     allow(compact_index).to receive(:log_specs) {}
   end
 
@@ -34,7 +36,7 @@
     describe "#available?" do
       before do
         allow(compact_index).to receive(:compact_index_client).
-          and_return(double(:compact_index_client, update_and_parse_checksums!: true))
+          and_return(double(:compact_index_client, available?: true))
       end
 
       it "returns true" do

From d2c4363e0c41c1512eb100981134db210c092126 Mon Sep 17 00:00:00 2001
From: Martin Emde <me@martinemde.com>
Date: Fri, 24 May 2024 13:11:31 -0700
Subject: [PATCH 195/242] [rubygems/rubygems] Add CompactIndexClient::Parser
 specs

https://github.com/rubygems/rubygems/commit/4bf455a498
---
 .../compact_index_client/parser_spec.rb       | 221 ++++++++++++++++++
 1 file changed, 221 insertions(+)
 create mode 100644 spec/bundler/bundler/compact_index_client/parser_spec.rb

diff --git a/spec/bundler/bundler/compact_index_client/parser_spec.rb b/spec/bundler/bundler/compact_index_client/parser_spec.rb
new file mode 100644
index 00000000000000..1d1d41a5a84711
--- /dev/null
+++ b/spec/bundler/bundler/compact_index_client/parser_spec.rb
@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "bundler/compact_index_client"
+require "bundler/compact_index_client/parser"
+
+TestCompactIndexClient = Struct.new(:names, :versions, :info_data) do
+  # Requiring the checksum to match the input data helps ensure
+  # that we are parsing the correct checksum from the versions file
+  def info(name, checksum)
+    info_data.dig(name, checksum)
+  end
+
+  def set_info_data(name, value)
+    info_data[name] = value
+  end
+end
+
+RSpec.describe Bundler::CompactIndexClient::Parser do
+  subject(:parser) { described_class.new(compact_index) }
+
+  let(:compact_index) { TestCompactIndexClient.new(names, versions, info_data) }
+  let(:names) { "a\nb\nc\n" }
+  let(:versions) { <<~VERSIONS }
+    a 1.0.0,1.0.1,1.1.0 aaa111
+    b 2.0.0,2.0.0-java bbb222
+    c 3.0.0,3.0.3,3.3.3 ccc333
+    c -3.0.3 ccc333yanked
+  VERSIONS
+  let(:info_data) do
+    {
+      "a" => { "aaa111" => a_info },
+      "b" => { "bbb222" => b_info },
+      "c" => { "ccc333yanked" => c_info },
+    }
+  end
+  let(:a_info) { <<~INFO }
+    1.0.0 |checksum:aaa1,ruby:>= 3.0.0,rubygems:>= 3.2.3
+    1.0.1 |checksum:aaa2,ruby:>= 3.0.0,rubygems:>= 3.2.3
+    1.1.0 |checksum:aaa3,ruby:>= 3.0.0,rubygems:>= 3.2.3
+  INFO
+  let(:b_info) { <<~INFO }
+    2.0.0 a:~> 1.0&<= 3.0|checksum:bbb1
+    2.0.0-java a:~> 1.0&<= 3.0|checksum:bbb2
+  INFO
+  let(:c_info) { <<~INFO }
+    3.0.0 a:= 1.0.0,b:~> 2.0|checksum:ccc1,ruby:>= 2.7.0,rubygems:>= 3.0.0
+    3.3.3 a:>= 1.1.0,b:~> 2.0|checksum:ccc3,ruby:>= 3.0.0,rubygems:>= 3.2.3
+  INFO
+
+  describe "#available?" do
+    it "returns true versions are available" do
+      expect(parser).to be_available
+    end
+
+    it "returns false when versions are not available" do
+      compact_index.versions = nil
+      expect(parser).not_to be_available
+    end
+  end
+
+  describe "#names" do
+    it "returns the names" do
+      expect(parser.names).to eq(%w[a b c])
+    end
+
+    it "returns an empty array when names is empty" do
+      compact_index.names = ""
+      expect(parser.names).to eq([])
+    end
+
+    it "returns an empty array when names is not readable" do
+      compact_index.names = nil
+      expect(parser.names).to eq([])
+    end
+  end
+
+  describe "#versions" do
+    it "returns the versions" do
+      expect(parser.versions).to eq(
+        "a" => [
+          ["a", "1.0.0"],
+          ["a", "1.0.1"],
+          ["a", "1.1.0"],
+        ],
+        "b" => [
+          ["b", "2.0.0"],
+          ["b", "2.0.0", "java"],
+        ],
+        "c" => [
+          ["c", "3.0.0"],
+          ["c", "3.3.3"],
+        ],
+      )
+    end
+
+    it "returns an empty hash when versions is empty" do
+      compact_index.versions = ""
+      expect(parser.versions).to eq({})
+    end
+
+    it "returns an empty hash when versions is not readable" do
+      compact_index.versions = nil
+      expect(parser.versions).to eq({})
+    end
+  end
+
+  describe "#info" do
+    it "returns the info for example gem 'a' which has no deps" do
+      expect(parser.info("a")).to eq(
+        [
+          [
+            "a",
+            "1.0.0",
+            nil,
+            [],
+            [
+              ["checksum", ["aaa1"]],
+              ["ruby", [">= 3.0.0"]],
+              ["rubygems", [">= 3.2.3"]],
+            ],
+          ],
+          [
+            "a",
+            "1.0.1",
+            nil,
+            [],
+            [
+              ["checksum", ["aaa2"]],
+              ["ruby", [">= 3.0.0"]],
+              ["rubygems", [">= 3.2.3"]],
+            ],
+          ],
+          [
+            "a",
+            "1.1.0",
+            nil,
+            [],
+            [
+              ["checksum", ["aaa3"]],
+              ["ruby", [">= 3.0.0"]],
+              ["rubygems", [">= 3.2.3"]],
+            ],
+          ],
+        ]
+      )
+    end
+
+    it "returns the info for example gem 'b' which has platform and compound deps" do
+      expect(parser.info("b")).to eq(
+        [
+          [
+            "b",
+            "2.0.0",
+            nil,
+            [
+              ["a", ["~> 1.0", "<= 3.0"]],
+            ],
+            [
+              ["checksum", ["bbb1"]],
+            ],
+          ],
+          [
+            "b",
+            "2.0.0",
+            "java",
+            [
+              ["a", ["~> 1.0", "<= 3.0"]],
+            ],
+            [
+              ["checksum", ["bbb2"]],
+            ],
+          ],
+        ]
+      )
+    end
+
+    it "returns the info for example gem 'c' which has deps and yanked version (requires use of correct info checksum)" do
+      expect(parser.info("c")).to eq(
+        [
+          [
+            "c",
+            "3.0.0",
+            nil,
+            [
+              ["a", ["= 1.0.0"]],
+              ["b", ["~> 2.0"]],
+            ],
+            [
+              ["checksum", ["ccc1"]],
+              ["ruby", [">= 2.7.0"]],
+              ["rubygems", [">= 3.0.0"]],
+            ],
+          ],
+          [
+            "c",
+            "3.3.3",
+            nil,
+            [
+              ["a", [">= 1.1.0"]],
+              ["b", ["~> 2.0"]],
+            ],
+            [
+              ["checksum", ["ccc3"]],
+              ["ruby", [">= 3.0.0"]],
+              ["rubygems", [">= 3.2.3"]],
+            ],
+          ],
+        ]
+      )
+    end
+
+    it "returns an empty array when the info is empty" do
+      compact_index.set_info_data("a", {})
+      expect(parser.info("a")).to eq([])
+    end
+
+    it "returns an empty array when the info is not readable" do
+      expect(parser.info("d")).to eq([])
+    end
+  end
+end

From 508f3310481c34fe146bcd6775041847d40520c9 Mon Sep 17 00:00:00 2001
From: Go <monkeywzr@gmail.com>
Date: Sun, 26 May 2024 17:28:21 +0900
Subject: [PATCH 196/242] [ruby/reline] allow space in config value
 (https://github.com/ruby/reline/pull/705)

* allow space in config value

fix https://github.com/ruby/reline/pull/657

* remove inline comments

* Revert "remove inline comments"

This reverts commit https://github.com/ruby/reline/commit/2438347c1a10.

* refactoring

* remove unnecessary comment handling

https://github.com/ruby/reline/commit/d60f1e1e39
---
 lib/reline/config.rb       | 17 +++++++++--------
 test/reline/test_config.rb | 12 +++++++++++-
 2 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/lib/reline/config.rb b/lib/reline/config.rb
index d44c2675abace0..62c6d105b3ef08 100644
--- a/lib/reline/config.rb
+++ b/lib/reline/config.rb
@@ -182,9 +182,10 @@ def read_lines(lines, file = nil)
       next if if_stack.any? { |_no, skip| skip }
 
       case line
-      when /^set +([^ ]+) +([^ ]+)/i
-        var, value = $1.downcase, $2
-        bind_variable(var, value)
+      when /^set +([^ ]+) +(.+)/i
+        # value ignores everything after a space, raw_value does not.
+        var, value, raw_value = $1.downcase, $2.partition(' ').first, $2
+        bind_variable(var, value, raw_value)
         next
       when /\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
         key, func_name = $1, $2
@@ -234,7 +235,7 @@ def handle_directive(directive, file, no, if_stack)
     end
   end
 
-  def bind_variable(name, value)
+  def bind_variable(name, value, raw_value)
     case name
     when 'history-size'
       begin
@@ -259,7 +260,7 @@ def bind_variable(name, value)
     when 'completion-query-items'
       @completion_query_items = value.to_i
     when 'isearch-terminators'
-      @isearch_terminators = retrieve_string(value)
+      @isearch_terminators = retrieve_string(raw_value)
     when 'editing-mode'
       case value
       when 'emacs'
@@ -301,11 +302,11 @@ def bind_variable(name, value)
         @show_mode_in_prompt = false
       end
     when 'vi-cmd-mode-string'
-      @vi_cmd_mode_string = retrieve_string(value)
+      @vi_cmd_mode_string = retrieve_string(raw_value)
     when 'vi-ins-mode-string'
-      @vi_ins_mode_string = retrieve_string(value)
+      @vi_ins_mode_string = retrieve_string(raw_value)
     when 'emacs-mode-string'
-      @emacs_mode_string = retrieve_string(value)
+      @emacs_mode_string = retrieve_string(raw_value)
     when *VARIABLE_NAMES then
       variable_name = :"@#{name.tr(?-, ?_)}"
       instance_variable_set(variable_name, value.nil? || value == '1' || value == 'on')
diff --git a/test/reline/test_config.rb b/test/reline/test_config.rb
index 6068292847c5af..03e4178f32378f 100644
--- a/test/reline/test_config.rb
+++ b/test/reline/test_config.rb
@@ -459,6 +459,17 @@ def test_inputrc
     ENV['INPUTRC'] = inputrc_backup
   end
 
+  def test_inputrc_raw_value
+    @config.read_lines(<<~'LINES'.lines)
+      set editing-mode vi ignored-string
+      set vi-ins-mode-string aaa aaa
+      set vi-cmd-mode-string bbb ccc # comment
+    LINES
+    assert_equal :vi_insert, @config.instance_variable_get(:@editing_mode_label)
+    assert_equal 'aaa aaa', @config.vi_ins_mode_string
+    assert_equal 'bbb ccc # comment', @config.vi_cmd_mode_string
+  end
+
   def test_inputrc_with_utf8
     # This file is encoded by UTF-8 so this heredoc string is also UTF-8.
     @config.read_lines(<<~'LINES'.lines)
@@ -542,4 +553,3 @@ def test_relative_xdg_config_home
     ENV['HOME'] = home_backup
   end
 end
-

From 0f9e50b8c5554d5a6a3f19044d0c9e276b7d414b Mon Sep 17 00:00:00 2001
From: eileencodes <eileencodes@gmail.com>
Date: Wed, 1 May 2024 15:17:20 -0400
Subject: [PATCH 197/242] Fix macos bug deleting too many files

Since #10209 we've been noticing that on macos after running `make
clean` the `coroutine/arm64/Context.S` file is missing, causing
subsequent make calls to fail because `Context.S` is needed to build
`Context.o`.

The reason this is happening is because macos is case-insensitive so the
`.s` looks for `coroutine/arm64/Context.s` and finds
`coroutine/arm64/Context.s`. This does not happen on linux because the
filesystem is case sensitive.

I attempted to use `find` because it is case sensitive regardless of
filesystem, but it was a lot slower than `rm` since we can't pass
multiple file names the same way to `find`.

Reverting this small part of #10209 fixes the issue for macos and it
wasn't clear that those changes were strictly necessary for the rest of
the PR.

We changed the original code to use `rm` instead of `delete` because it
is not standarized on POSIX.
---
 template/Makefile.in | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/template/Makefile.in b/template/Makefile.in
index 813a727cf9f4db..22148e7feaba94 100644
--- a/template/Makefile.in
+++ b/template/Makefile.in
@@ -493,9 +493,8 @@ clean-local::
 	  enc/encinit.c enc/encinit.$(OBJEXT) $(pkgconfig_DATA) \
 	  ruby-runner.$(OBJEXT) ruby-runner.h \
 	|| $(NULLCMD)
-	@$(RM) $(ALLOBJS:.$(OBJEXT)=.bc)
-	@$(RM) $(ALLOBJS:.$(OBJEXT)=.i)
-	@$(RM) $(ALLOBJS:.$(OBJEXT)=.s)
+	$(Q)find . ! -type d \( -name '*.bc' -o -name '*.[is]' \) -exec rm -f {} + || true
+
 
 distclean-local::
 	$(Q)$(RM) \

From bc50f2a3f1d166be3899f32b81bb78f666000592 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 26 May 2024 20:14:18 +0900
Subject: [PATCH 198/242] Debug unexpectedly changed path

---
 error.c                   | 6 ++++--
 test/ruby/test_literal.rb | 9 +++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/error.c b/error.c
index 5f8111df57f470..4398019b407e01 100644
--- a/error.c
+++ b/error.c
@@ -2719,8 +2719,10 @@ syntax_error_with_path(VALUE exc, VALUE path, VALUE *mesg, rb_encoding *enc)
         rb_ivar_set(exc, id_i_path, path);
     }
     else {
-        if (rb_attr_get(exc, id_i_path) != path) {
-            rb_raise(rb_eArgError, "SyntaxError#path changed");
+        VALUE old_path = rb_attr_get(exc, id_i_path);
+        if (old_path != path) {
+            rb_raise(rb_eArgError, "SyntaxError#path changed: %+"PRIsVALUE"->%+"PRIsVALUE,
+                     old_path, path);
         }
         VALUE s = *mesg = rb_attr_get(exc, idMesg);
         if (RSTRING_LEN(s) > 0 && *(RSTRING_END(s)-1) != '\n')
diff --git a/test/ruby/test_literal.rb b/test/ruby/test_literal.rb
index c6154af1f61161..b0fd4680b3f6fd 100644
--- a/test/ruby/test_literal.rb
+++ b/test/ruby/test_literal.rb
@@ -640,11 +640,16 @@ def test_float
           end
           begin
             r2 = eval(s)
-          rescue NameError, SyntaxError
+          rescue SyntaxError => e
+            r2 = :err
+          rescue NameError
             r2 = :err
           end
           r2 = :err if Range === r2
-          assert_equal(r1, r2, "Float(#{s.inspect}) != eval(#{s.inspect})")
+          s = s.inspect
+          mesg = "Float(#{s}) != eval(#{s})"
+          mesg << ":" << e.message if e
+          assert_equal(r1, r2, mesg)
         }
       }
     }

From 0d44e23831d5bbebb273081b5eef7ed60f55abbc Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 26 May 2024 22:17:57 +0900
Subject: [PATCH 199/242] Prevent test-bundled-gems outputs from mixing

Run test-bundled-gems-run and test-bundled-gems-spec sequentially.
---
 common.mk     | 6 ++++--
 defs/gmake.mk | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/common.mk b/common.mk
index 65e785c5fb8e3d..42c9c658031d93 100644
--- a/common.mk
+++ b/common.mk
@@ -1591,7 +1591,7 @@ yes-test-bundled-gems-prepare: yes-test-bundled-gems-precheck
 	$(ACTIONS_ENDGROUP)
 
 PREPARE_BUNDLED_GEMS = test-bundled-gems-prepare
-test-bundled-gems: $(TEST_RUNNABLE)-test-bundled-gems $(TEST_RUNNABLE)-test-bundled-gems-spec
+test-bundled-gems: $(TEST_RUNNABLE)-test-bundled-gems $(DOT_WAIT) $(TEST_RUNNABLE)-test-bundled-gems-spec
 yes-test-bundled-gems: test-bundled-gems-run
 no-test-bundled-gems:
 
@@ -1599,8 +1599,10 @@ no-test-bundled-gems:
 # TEST_BUNDLED_GEMS_ALLOW_FAILURES =
 
 BUNDLED_GEMS =
-test-bundled-gems-run: $(PREPARE_BUNDLED_GEMS)
+test-bundled-gems-run: $(TEST_RUNNABLE)-test-bundled-gems-run
+yes-test-bundled-gems-run: $(PREPARE_BUNDLED_GEMS)
 	$(gnumake_recursive)$(Q) $(XRUBY) $(tooldir)/test-bundled-gems.rb $(BUNDLED_GEMS)
+no-test-bundled-gems-run: $(PREPARE_BUNDLED_GEMS)
 
 test-bundled-gems-spec: $(TEST_RUNNABLE)-test-bundled-gems-spec
 yes-test-bundled-gems-spec: yes-test-spec-precheck $(PREPARE_BUNDLED_GEMS)
diff --git a/defs/gmake.mk b/defs/gmake.mk
index c914b39690d50f..b34e8420baeca4 100644
--- a/defs/gmake.mk
+++ b/defs/gmake.mk
@@ -37,7 +37,7 @@ TEST_TARGETS := $(patsubst test,test-short,$(TEST_TARGETS))
 TEST_DEPENDS := $(filter-out test $(TEST_TARGETS),$(TEST_DEPENDS))
 TEST_TARGETS := $(patsubst test-short,btest-ruby test-knownbug test-basic,$(TEST_TARGETS))
 TEST_TARGETS := $(patsubst test-basic,test-basic test-leaked-globals,$(TEST_TARGETS))
-TEST_TARGETS := $(patsubst test-bundled-gems,test-bundled-gems-run,$(TEST_TARGETS))
+TEST_TARGETS := $(patsubst test-bundled-gems,test-bundled-gems-spec test-bundled-gems-run,$(TEST_TARGETS))
 TEST_TARGETS := $(patsubst test-bundled-gems-run,test-bundled-gems-run $(PREPARE_BUNDLED_GEMS),$(TEST_TARGETS))
 TEST_TARGETS := $(patsubst test-bundled-gems-prepare,test-bundled-gems-prepare $(PRECHECK_BUNDLED_GEMS) test-bundled-gems-fetch,$(TEST_TARGETS))
 TEST_TARGETS := $(patsubst test-bundler-parallel,test-bundler-parallel $(PREPARE_BUNDLER),$(TEST_TARGETS))
@@ -97,6 +97,7 @@ ORDERED_TEST_TARGETS := $(filter $(TEST_TARGETS), \
 	test-bundler-prepare test-bundler test-bundler-parallel \
 	test-bundled-gems-precheck test-bundled-gems-fetch \
 	test-bundled-gems-prepare test-bundled-gems-run \
+	test-bundled-gems-spec \
 	)
 
 # grep ^yes-test-.*-precheck: template/Makefile.in defs/gmake.mk common.mk

From 4949f0a928da079b07c73a5eccfdde0cb121ca1e Mon Sep 17 00:00:00 2001
From: Marcus Stollsteimer <sto.mar@web.de>
Date: Sun, 26 May 2024 14:36:57 +0200
Subject: [PATCH 200/242] [rubygems/rubygems] Fix typo in description of
 build:checksum task

https://github.com/rubygems/rubygems/commit/351ff2512f
---
 lib/bundler/gem_helper.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/bundler/gem_helper.rb b/lib/bundler/gem_helper.rb
index d535d54f9bb0d9..5ce0ef6280037b 100644
--- a/lib/bundler/gem_helper.rb
+++ b/lib/bundler/gem_helper.rb
@@ -47,7 +47,7 @@ def install
         built_gem_path = build_gem
       end
 
-      desc "Generate SHA512 checksum if #{name}-#{version}.gem into the checksums directory."
+      desc "Generate SHA512 checksum of #{name}-#{version}.gem into the checksums directory."
       task "build:checksum" => "build" do
         build_checksum(built_gem_path)
       end

From 5853a3804382e2935bb23917080ceea647d19161 Mon Sep 17 00:00:00 2001
From: License Update <license.update@rubygems.org>
Date: Sun, 26 May 2024 00:25:52 +0000
Subject: [PATCH 201/242] [rubygems/rubygems] Update SPDX license list as of
 2024-05-22

https://github.com/rubygems/rubygems/commit/f91ac04397
---
 lib/rubygems/util/licenses.rb | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/lib/rubygems/util/licenses.rb b/lib/rubygems/util/licenses.rb
index f3c720163914e7..192ae30b9b6b1c 100644
--- a/lib/rubygems/util/licenses.rb
+++ b/lib/rubygems/util/licenses.rb
@@ -15,6 +15,7 @@ class Gem::Licenses
   # license identifiers
   LICENSE_IDENTIFIERS = %w[
     0BSD
+    3D-Slicer-1.0
     AAL
     ADSL
     AFL-1.1
@@ -26,6 +27,7 @@ class Gem::Licenses
     AGPL-1.0-or-later
     AGPL-3.0-only
     AGPL-3.0-or-later
+    AMD-newlib
     AMDPLPA
     AML
     AML-glslang
@@ -62,6 +64,7 @@ class Gem::Licenses
     BSD-2-Clause-Darwin
     BSD-2-Clause-Patent
     BSD-2-Clause-Views
+    BSD-2-Clause-first-lines
     BSD-3-Clause
     BSD-3-Clause-Attribution
     BSD-3-Clause-Clear
@@ -191,6 +194,7 @@ class Gem::Licenses
     CUA-OPL-1.0
     Caldera
     Caldera-no-preamble
+    Catharon
     ClArtistic
     Clips
     Community-Spec-1.0
@@ -270,25 +274,32 @@ class Gem::Licenses
     Glide
     Glulxe
     Graphics-Gems
+    Gutmann
     HP-1986
     HP-1989
     HPND
     HPND-DEC
     HPND-Fenneberg-Livingston
     HPND-INRIA-IMAG
+    HPND-Intel
     HPND-Kevlin-Henney
     HPND-MIT-disclaimer
     HPND-Markus-Kuhn
     HPND-Pbmplus
     HPND-UC
+    HPND-UC-export-US
     HPND-doc
     HPND-doc-sell
     HPND-export-US
+    HPND-export-US-acknowledgement
     HPND-export-US-modify
+    HPND-export2-US
+    HPND-merchantability-variant
     HPND-sell-MIT-disclaimer-xserver
     HPND-sell-regexpr
     HPND-sell-variant
     HPND-sell-variant-MIT-disclaimer
+    HPND-sell-variant-MIT-disclaimer-rev
     HTMLTIDY
     HaskellReport
     Hippocratic-2.1
@@ -353,6 +364,7 @@ class Gem::Licenses
     MIT-0
     MIT-CMU
     MIT-Festival
+    MIT-Khronos-old
     MIT-Modern-Variant
     MIT-Wu
     MIT-advertising
@@ -386,7 +398,9 @@ class Gem::Licenses
     NAIST-2003
     NASA-1.3
     NBPL-1.0
+    NCBI-PD
     NCGL-UK-2.0
+    NCL
     NCSA
     NGPL
     NICTA-1.0
@@ -410,6 +424,7 @@ class Gem::Licenses
     Nokia
     Noweb
     O-UDA-1.0
+    OAR
     OCCT-PL
     OCLC-2.0
     ODC-By-1.0
@@ -463,6 +478,7 @@ class Gem::Licenses
     PDDL-1.0
     PHP-3.0
     PHP-3.01
+    PPL
     PSF-2.0
     Parity-6.0.0
     Parity-7.0.0
@@ -518,6 +534,7 @@ class Gem::Licenses
     Spencer-99
     SugarCRM-1.1.3
     Sun-PPP
+    Sun-PPP-2000
     SunPro
     Symlinks
     TAPR-OHL-1.0
@@ -574,6 +591,7 @@ class Gem::Licenses
     Zimbra-1.3
     Zimbra-1.4
     Zlib
+    any-OSI
     bcrypt-Solar-Designer
     blessing
     bzip2-1.0.6
@@ -582,6 +600,7 @@ class Gem::Licenses
     copyleft-next-0.3.0
     copyleft-next-0.3.1
     curl
+    cve-tou
     diffmark
     dtoa
     dvipdfm
@@ -604,6 +623,7 @@ class Gem::Licenses
     mpi-permissive
     mpich2
     mplus
+    pkgconf
     pnmstitch
     psfrag
     psutils
@@ -613,12 +633,14 @@ class Gem::Licenses
     softSurfer
     ssh-keyscan
     swrule
+    threeparttable
     ulem
     w3m
     xinetd
     xkeyboard-config-Zinoviev
     xlock
     xpp
+    xzoom
     zlib-acknowledgement
   ].freeze
 
@@ -660,6 +682,7 @@ class Gem::Licenses
   EXCEPTION_IDENTIFIERS = %w[
     389-exception
     Asterisk-exception
+    Asterisk-linking-protocols-exception
     Autoconf-exception-2.0
     Autoconf-exception-3.0
     Autoconf-exception-generic
@@ -697,11 +720,13 @@ class Gem::Licenses
     OCCT-exception-1.0
     OCaml-LGPL-linking-exception
     OpenJDK-assembly-exception-1.0
+    PCRE2-exception
     PS-or-PDF-font-exception-20170817
     QPL-1.0-INRIA-2004-exception
     Qt-GPL-exception-1.0
     Qt-LGPL-exception-1.1
     Qwt-exception-1.0
+    RRDtool-FLOSS-exception-2.0
     SANE-exception
     SHL-2.0
     SHL-2.1

From f4b475993eefa98cd6c8d2b109aea525993b6f0b Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Mon, 27 May 2024 12:41:38 +0900
Subject: [PATCH 202/242] Apply optimizations for `putstring` to
 `putchilledstring` as well

---
 compile.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compile.c b/compile.c
index bdccd36cf58344..0113d0e0ebbd0a 100644
--- a/compile.c
+++ b/compile.c
@@ -3080,7 +3080,7 @@ iseq_pop_newarray(rb_iseq_t *iseq, INSN *iobj)
 static int
 is_frozen_putstring(INSN *insn, VALUE *op)
 {
-    if (IS_INSN_ID(insn, putstring)) {
+    if (IS_INSN_ID(insn, putstring) || IS_INSN_ID(insn, putchilledstring)) {
         *op = OPERAND_AT(insn, 0);
         return 1;
     }
@@ -3122,6 +3122,7 @@ optimize_checktype(rb_iseq_t *iseq, INSN *iobj)
 
     switch (INSN_OF(iobj)) {
       case BIN(putstring):
+      case BIN(putchilledstring):
         type = INT2FIX(T_STRING);
         break;
       case BIN(putnil):
@@ -3549,6 +3550,7 @@ iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcal
             enum ruby_vminsn_type previ = ((INSN *)prev)->insn_id;
             if (previ == BIN(putobject) || previ == BIN(putnil) ||
                 previ == BIN(putself) || previ == BIN(putstring) ||
+                previ == BIN(putchilledstring) ||
                 previ == BIN(dup) ||
                 previ == BIN(getlocal) ||
                 previ == BIN(getblockparam) ||
@@ -3690,7 +3692,7 @@ iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcal
         }
     }
 
-    if (IS_INSN_ID(iobj, putstring) ||
+    if (IS_INSN_ID(iobj, putstring) || IS_INSN_ID(iobj, putchilledstring) ||
         (IS_INSN_ID(iobj, putobject) && RB_TYPE_P(OPERAND_AT(iobj, 0), T_STRING))) {
         /*
          *  putstring ""
@@ -4080,7 +4082,7 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
                 }
             }
         }
-        else if ((IS_INSN_ID(niobj, putstring) ||
+        else if ((IS_INSN_ID(niobj, putstring) || IS_INSN_ID(niobj, putchilledstring) ||
                   (IS_INSN_ID(niobj, putobject) && RB_TYPE_P(OPERAND_AT(niobj, 0), T_STRING))) &&
                  IS_NEXT_INSN_ID(&niobj->link, send)) {
             const struct rb_callinfo *ci = (struct rb_callinfo *)OPERAND_AT((INSN *)niobj->link.next, 0);

From 4fee1019f607cdbfd6c55fc5ca587de04cb3cb65 Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Mon, 27 May 2024 12:56:07 +0900
Subject: [PATCH 203/242] Try to upload core file on macos GitHub Actions

A core dump occurred, but failed to capture the core file.
https://app.launchableinc.com/organizations/ruby/workspaces/ruby/data/test-sessions/2935062?tab=retried-tests

Looks like a core file was not created. I am not unsure why, so make
sure that the /cores directory is writable and try `ulimit` command.
---
 .github/workflows/macos.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 151df8126bec59..3d97c092f7dbdb 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -74,6 +74,7 @@ jobs:
         run: |
           sysctl -n kern.coredump
           sudo sysctl -w kern.coredump=1
+          sudo chmod -R +rwx /cores/
 
       - name: Run configure
         run: ../src/configure -C --disable-install-doc ${ruby_configure_args}
@@ -115,6 +116,7 @@ jobs:
 
       - name: make skipped tests
         run: |
+          ulimit -c unlimited
           make -s test-all TESTS="${TESTS//-n!\//-n/}"
         env:
           GNUMAKEFLAGS: ''

From bc47ca5546a1287fbb052329075293c200d830b0 Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Mon, 27 May 2024 18:16:28 +0900
Subject: [PATCH 204/242] Add a debug print for a random failure

```
  1) Error:
TestRubyLiteral#test_float:
ArgumentError: SyntaxError#path changed: "(eval at /home/chkbuild/chkbuild/tmp/build/20240527T050036Z/ruby/test/ruby/test_literal.rb:642)"->"(eval at /home/chkbuild/chkbuild/tmp/build/20240527T050036Z/ruby/test/ruby/test_literal.rb:642)"
```
https://rubyci.s3.amazonaws.com/s390x/ruby-master/log/20240527T050036Z.fail.html.gz
---
 test/ruby/test_literal.rb | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/ruby/test_literal.rb b/test/ruby/test_literal.rb
index b0fd4680b3f6fd..8732d8f0d0f19a 100644
--- a/test/ruby/test_literal.rb
+++ b/test/ruby/test_literal.rb
@@ -640,6 +640,10 @@ def test_float
           end
           begin
             r2 = eval(s)
+          rescue ArgumentError
+            # Debug log for a random failure: ArgumentError: SyntaxError#path changed
+            $stderr.puts "TestRubyLiteral#test_float failed: %p" % s
+            raise
           rescue SyntaxError => e
             r2 = :err
           rescue NameError

From 7c6e4bc7ca8a25de801db49eae9cad0c9edb29c0 Mon Sep 17 00:00:00 2001
From: verdy89 <verdy.ir.89@gmail.com>
Date: Tue, 28 May 2024 01:38:19 +0900
Subject: [PATCH 205/242] [ruby/reline] Implement the redo command
 (https://github.com/ruby/reline/pull/707)

* Implement the redo command

* Commented out a test that does not pass

* Changed key assignment for redo from "\C-[" to "\C-g"

* Changed redo key assignment from `\C-g` to `\M-\C-_`

* Revert the first implemantation

* Implemented redo by sharing `@past_lines` between undo and redo

* Fixed the index of past_lines that is updated when the cursor is moved

* Fixed deletion of the redo history in regular input

* Renamed variables: past_lines -> input_lines

* Rename @position to @input_lines_position

* Deleted unused variables: `@old_byte_pointer` and `@old_line_index`

https://github.com/ruby/reline/commit/0b2d9fab5f
---
 lib/reline/key_actor/emacs.rb               |   2 +-
 lib/reline/line_editor.rb                   |  47 +++++----
 test/reline/test_key_actor_emacs.rb         | 106 +++++++++++++++++++-
 test/reline/yamatanooroti/test_rendering.rb |  16 +++
 4 files changed, 152 insertions(+), 19 deletions(-)

diff --git a/lib/reline/key_actor/emacs.rb b/lib/reline/key_actor/emacs.rb
index edd88289a3c940..d7354520b0a54f 100644
--- a/lib/reline/key_actor/emacs.rb
+++ b/lib/reline/key_actor/emacs.rb
@@ -319,7 +319,7 @@ class Reline::KeyActor::Emacs < Reline::KeyActor::Base
     # 158 M-^^
     :ed_unassigned,
     # 159 M-^_
-    :ed_unassigned,
+    :redo,
     # 160 M-SPACE
     :em_set_mark,
     # 161 M-!
diff --git a/lib/reline/line_editor.rb b/lib/reline/line_editor.rb
index 23ece602203432..8f6421fb108bcd 100644
--- a/lib/reline/line_editor.rb
+++ b/lib/reline/line_editor.rb
@@ -250,7 +250,8 @@ def reset_variables(prompt = '', encoding:)
     @resized = false
     @cache = {}
     @rendered_screen = RenderedScreen.new(base_y: 0, lines: [], cursor_y: 0)
-    @past_lines = []
+    @input_lines = [[[""], 0, 0]]
+    @input_lines_position = 0
     @undoing = false
     reset_line
   end
@@ -1137,7 +1138,7 @@ def input_key(key)
       @completion_journey_state = nil
     end
 
-    push_past_lines unless @undoing
+    push_input_lines unless @undoing
     @undoing = false
 
     if @in_pasting
@@ -1156,21 +1157,24 @@ def input_key(key)
 
   def save_old_buffer
     @old_buffer_of_lines = @buffer_of_lines.dup
-    @old_byte_pointer = @byte_pointer.dup
-    @old_line_index = @line_index.dup
   end
 
-  def push_past_lines
-    if @old_buffer_of_lines != @buffer_of_lines
-      @past_lines.push([@old_buffer_of_lines, @old_byte_pointer, @old_line_index])
+  def push_input_lines
+    if @old_buffer_of_lines == @buffer_of_lines
+      @input_lines[@input_lines_position] = [@buffer_of_lines.dup, @byte_pointer, @line_index]
+    else
+      @input_lines = @input_lines[0..@input_lines_position]
+      @input_lines_position += 1
+      @input_lines.push([@buffer_of_lines.dup, @byte_pointer, @line_index])
     end
-    trim_past_lines
+    trim_input_lines
   end
 
-  MAX_PAST_LINES = 100
-  def trim_past_lines
-    if @past_lines.size > MAX_PAST_LINES
-      @past_lines.shift
+  MAX_INPUT_LINES = 100
+  def trim_input_lines
+    if @input_lines.size > MAX_INPUT_LINES
+      @input_lines.shift
+      @input_lines_position -= 1
     end
   end
 
@@ -1352,7 +1356,7 @@ def insert_pasted_text(text)
     @buffer_of_lines[@line_index, 1] = lines
     @line_index += lines.size - 1
     @byte_pointer = @buffer_of_lines[@line_index].bytesize - post.bytesize
-    push_past_lines
+    push_input_lines
   end
 
   def insert_text(text)
@@ -2529,13 +2533,22 @@ def finish
   end
 
   private def undo(_key)
-    return if @past_lines.empty?
+    @undoing = true
+
+    return if @input_lines_position <= 0
+
+    @input_lines_position -= 1
+    target_lines, target_cursor_x, target_cursor_y = @input_lines[@input_lines_position]
+    set_current_lines(target_lines.dup, target_cursor_x, target_cursor_y)
+  end
 
+  private def redo(_key)
     @undoing = true
 
-    target_lines, target_cursor_x, target_cursor_y = @past_lines.last
-    set_current_lines(target_lines, target_cursor_x, target_cursor_y)
+    return if @input_lines_position >= @input_lines.size - 1
 
-    @past_lines.pop
+    @input_lines_position += 1
+    target_lines, target_cursor_x, target_cursor_y = @input_lines[@input_lines_position]
+    set_current_lines(target_lines.dup, target_cursor_x, target_cursor_y)
   end
 end
diff --git a/test/reline/test_key_actor_emacs.rb b/test/reline/test_key_actor_emacs.rb
index 013ca2f7b36040..a2ea060ab951bd 100644
--- a/test/reline/test_key_actor_emacs.rb
+++ b/test/reline/test_key_actor_emacs.rb
@@ -1498,11 +1498,115 @@ def test_undo_with_multiline
   end
 
   def test_undo_with_many_times
-    str = "a" + "b" * 100
+    str = "a" + "b" * 99
     input_keys(str, false)
     100.times { input_keys("\C-_", false) }
     assert_line_around_cursor('a', '')
     input_keys("\C-_", false)
     assert_line_around_cursor('a', '')
   end
+
+  def test_redo
+    input_keys("aあb", false)
+    assert_line_around_cursor('aあb', '')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('aあb', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('aあb', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('aあ', '')
+    input_keys("c", false)
+    assert_line_around_cursor('aあc', '')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('aあc', '')
+  end
+
+  def test_redo_with_cursor_position
+    input_keys("abc\C-b\C-h", false)
+    assert_line_around_cursor('a', 'c')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('a', 'c')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('ab', 'c')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor('a', 'c')
+  end
+
+  def test_redo_with_multiline
+    @line_editor.multiline_on
+    @line_editor.confirm_multiline_termination_proc = proc {}
+    input_keys("1\n2\n3", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(2)
+    assert_line_around_cursor('3', '')
+
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", ""])
+    assert_line_index(2)
+    assert_line_around_cursor('', '')
+
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+
+    input_keys("\M-\C-_", false)
+    assert_whole_lines(["1", "2", ""])
+    assert_line_index(2)
+    assert_line_around_cursor('', '')
+
+    input_keys("\M-\C-_", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(2)
+    assert_line_around_cursor('3', '')
+
+    input_keys("\C-p\C-h\C-h", false)
+    assert_whole_lines(["1", "3"])
+    assert_line_index(0)
+    assert_line_around_cursor('1', '')
+
+    input_keys("\C-n", false)
+    assert_whole_lines(["1", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('3', '')
+
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('', '')
+
+    input_keys("\C-_", false)
+    assert_whole_lines(["1", "2", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('2', '')
+
+    input_keys("\M-\C-_", false)
+    assert_whole_lines(["1", "", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('', '')
+
+    input_keys("\M-\C-_", false)
+    assert_whole_lines(["1", "3"])
+    assert_line_index(1)
+    assert_line_around_cursor('3', '')
+  end
+
+  def test_redo_with_many_times
+    str = "a" + "b" * 98 + "c"
+    input_keys(str, false)
+    100.times { input_keys("\C-_", false) }
+    assert_line_around_cursor('a', '')
+    input_keys("\C-_", false)
+    assert_line_around_cursor('a', '')
+    100.times { input_keys("\M-\C-_", false) }
+    assert_line_around_cursor(str, '')
+    input_keys("\M-\C-_", false)
+    assert_line_around_cursor(str, '')
+  end
 end
diff --git a/test/reline/yamatanooroti/test_rendering.rb b/test/reline/yamatanooroti/test_rendering.rb
index 37a1c1a1930907..1cf46b4cd1cfd0 100644
--- a/test/reline/yamatanooroti/test_rendering.rb
+++ b/test/reline/yamatanooroti/test_rendering.rb
@@ -569,6 +569,22 @@ def test_bracketed_paste_with_undo
       EOC
     end
 
+    def test_bracketed_paste_with_redo
+      omit if Reline.core.io_gate.win?
+      start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
+      write("abc")
+      write("\e[200~def hoge\r\t3\rend\e[201~")
+      write("\C-_")
+      write("\M-\C-_")
+      close
+      assert_screen(<<~EOC)
+        Multiline REPL.
+        prompt> abcdef hoge
+        prompt>   3
+        prompt> end
+      EOC
+    end
+
     def test_backspace_until_returns_to_initial
       start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/test/reline/yamatanooroti/multiline_repl}, startup_message: 'Multiline REPL.')
       write("ABC")

From 2114d0af1e5790da365584a38ea7ee58670dc11b Mon Sep 17 00:00:00 2001
From: Yusuke Endoh <mame@ruby-lang.org>
Date: Tue, 28 May 2024 12:04:34 +0900
Subject: [PATCH 206/242] Make test_nested_timeouts less flaky

This test randomly fails due to the bug reported in [Bug #20314], where
the two timeouts are too close so that they can expire at the same time.

As a workaround, this change increases the time difference between
timeouts. This will reduce the probability of simultaneous expirations
and lower flakiness.
---
 test/test_timeout.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_timeout.rb b/test/test_timeout.rb
index e900b10cd716ec..34966f92a4b499 100644
--- a/test/test_timeout.rb
+++ b/test/test_timeout.rb
@@ -66,7 +66,7 @@ def test_nested_timeout
     a = nil
     assert_raise(Timeout::Error) do
       Timeout.timeout(0.1) {
-        Timeout.timeout(1) {
+        Timeout.timeout(30) {
           nil while true
         }
         a = 1
@@ -84,7 +84,7 @@ class MyNewErrorInner < StandardError; end
   def test_nested_timeout_error_identity
     begin
       Timeout.timeout(0.1, MyNewErrorOuter) {
-        Timeout.timeout(1, MyNewErrorInner) {
+        Timeout.timeout(30, MyNewErrorInner) {
           nil while true
         }
       }

From 1376881e9afe6ff673f64afa791cf30f57147ee2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20Barri=C3=A9?= <etienne.barrie@gmail.com>
Date: Mon, 27 May 2024 11:22:39 +0200
Subject: [PATCH 207/242] Stop marking chilled strings as frozen

They were initially made frozen to avoid false positives for cases such
as:

    str = str.dup if str.frozen?

But this may cause bugs and is generally confusing for users.

[Feature #20205]

Co-authored-by: Jean Boussier <byroot@ruby-lang.org>
---
 NEWS.md                                       |  4 ++--
 error.c                                       |  5 -----
 include/ruby/internal/intern/error.h          | 10 ++++++++++
 internal/string.h                             |  9 ++++++---
 ractor.c                                      | 18 ++----------------
 spec/ruby/command_line/frozen_strings_spec.rb | 12 ++----------
 spec/ruby/core/string/chilled_string_spec.rb  | 12 +++++++-----
 string.c                                      |  5 ++++-
 test/ruby/test_rubyoptions.rb                 |  3 ---
 test/ruby/test_string.rb                      |  7 +++----
 yjit/bindgen/src/main.rs                      |  1 +
 yjit/src/codegen.rs                           |  2 +-
 yjit/src/cruby_bindings.inc.rs                |  2 ++
 13 files changed, 40 insertions(+), 50 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 9ec9448d89747c..539fb84d92c123 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -7,8 +7,8 @@ Note that each entry is kept to a minimum, see links for details.
 
 ## Language changes
 
-* String literals in files without a `frozen_string_literal` comment now behave
-  as if they were frozen. If they are mutated a deprecation warning is emitted.
+* String literals in files without a `frozen_string_literal` comment now emit a deprecation warning
+  when they are mutated.
   These warnings can be enabled with `-W:deprecated` or by setting `Warning[:deprecated] = true`.
   To disable this change, you can run Ruby with the `--disable-frozen-string-literal`
   command line argument. [[Feature #20205]]
diff --git a/error.c b/error.c
index 4398019b407e01..6d79f789d2b286 100644
--- a/error.c
+++ b/error.c
@@ -3884,11 +3884,6 @@ rb_error_frozen_object(VALUE frozen_obj)
 {
     rb_yjit_lazy_push_frame(GET_EC()->cfp->pc);
 
-    if (CHILLED_STRING_P(frozen_obj)) {
-        CHILLED_STRING_MUTATED(frozen_obj);
-        return;
-    }
-
     VALUE debug_info;
     const ID created_info = id_debug_created_info;
     VALUE mesg = rb_sprintf("can't modify frozen %"PRIsVALUE": ",
diff --git a/include/ruby/internal/intern/error.h b/include/ruby/internal/intern/error.h
index 11e147a12103fb..c56db91b4fd239 100644
--- a/include/ruby/internal/intern/error.h
+++ b/include/ruby/internal/intern/error.h
@@ -190,6 +190,7 @@ RBIMPL_ATTR_NONNULL(())
  */
 void rb_error_frozen(const char *what);
 
+RBIMPL_ATTR_NORETURN()
 /**
  * Identical  to  rb_error_frozen(),  except  it takes  arbitrary  Ruby  object
  * instead of C's string.
@@ -236,6 +237,9 @@ RBIMPL_ATTR_NORETURN()
  */
 void rb_error_arity(int argc, int min, int max);
 
+bool rb_str_chilled_p(VALUE str);
+void rb_str_modify(VALUE str);
+
 RBIMPL_SYMBOL_EXPORT_END()
 
 /**
@@ -248,12 +252,18 @@ RBIMPL_SYMBOL_EXPORT_END()
         if (RB_UNLIKELY(RB_OBJ_FROZEN(frozen_obj))) { \
             rb_error_frozen_object(frozen_obj); \
         } \
+        if (RB_UNLIKELY(rb_str_chilled_p(frozen_obj))) { \
+            rb_str_modify(frozen_obj); \
+        } \
     } while (0)
 
 /** @alias{rb_check_frozen} */
 static inline void
 rb_check_frozen_inline(VALUE obj)
 {
+    if (rb_str_chilled_p(obj)) {
+        rb_str_modify(obj);
+    }
     if (RB_UNLIKELY(RB_OBJ_FROZEN(obj))) {
         rb_error_frozen_object(obj);
     }
diff --git a/internal/string.h b/internal/string.h
index fb37f731147096..3333b3afc3c1d7 100644
--- a/internal/string.h
+++ b/internal/string.h
@@ -19,6 +19,10 @@
 #define STR_SHARED       FL_USER2 /* = ELTS_SHARED */
 #define STR_CHILLED      FL_USER3
 
+enum ruby_rstring_private_flags {
+    RSTRING_CHILLED = STR_CHILLED,
+};
+
 #ifdef rb_fstring_cstr
 # undef rb_fstring_cstr
 #endif
@@ -118,15 +122,14 @@ CHILLED_STRING_P(VALUE obj)
 static inline void
 CHILLED_STRING_MUTATED(VALUE str)
 {
+    FL_UNSET_RAW(str, STR_CHILLED);
     rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "literal string will be frozen in the future");
-    FL_UNSET_RAW(str, STR_CHILLED | FL_FREEZE);
 }
 
 static inline void
 STR_CHILL_RAW(VALUE str)
 {
-    // Chilled strings are always also frozen
-    FL_SET_RAW(str, STR_CHILLED | RUBY_FL_FREEZE);
+    FL_SET_RAW(str, STR_CHILLED);
 }
 
 static inline bool
diff --git a/ractor.c b/ractor.c
index 231a83db6fa5d3..d08a009d641545 100644
--- a/ractor.c
+++ b/ractor.c
@@ -2984,10 +2984,7 @@ rb_obj_traverse(VALUE obj,
 static int
 frozen_shareable_p(VALUE obj, bool *made_shareable)
 {
-    if (CHILLED_STRING_P(obj)) {
-        return false;
-    }
-    else if (!RB_TYPE_P(obj, T_DATA)) {
+    if (!RB_TYPE_P(obj, T_DATA)) {
         return true;
     }
     else if (RTYPEDDATA_P(obj)) {
@@ -3016,18 +3013,7 @@ make_shareable_check_shareable(VALUE obj)
     if (rb_ractor_shareable_p(obj)) {
         return traverse_skip;
     }
-    else if (CHILLED_STRING_P(obj)) {
-        rb_funcall(obj, idFreeze, 0);
-
-        if (UNLIKELY(!RB_OBJ_FROZEN_RAW(obj))) {
-            rb_raise(rb_eRactorError, "#freeze does not freeze object correctly");
-        }
-
-        if (RB_OBJ_SHAREABLE_P(obj)) {
-            return traverse_skip;
-        }
-    }
-    else if (!frozen_shareable_p(obj, &made_shareable)) {
+    if (!frozen_shareable_p(obj, &made_shareable)) {
         if (made_shareable) {
             return traverse_skip;
         }
diff --git a/spec/ruby/command_line/frozen_strings_spec.rb b/spec/ruby/command_line/frozen_strings_spec.rb
index 334b98273b7827..06889755d254cf 100644
--- a/spec/ruby/command_line/frozen_strings_spec.rb
+++ b/spec/ruby/command_line/frozen_strings_spec.rb
@@ -42,16 +42,8 @@
     ruby_exe(fixture(__FILE__, "freeze_flag_one_literal.rb")).chomp.should == "false"
   end
 
-  ruby_version_is "3.4" do
-    it "if file has no frozen_string_literal comment produce different frozen strings each time" do
-      ruby_exe(fixture(__FILE__, "string_literal_raw.rb")).chomp.should == "frozen:true interned:false"
-    end
-  end
-
-  ruby_version_is ""..."3.4" do
-    it "if file has no frozen_string_literal comment produce different mutable strings each time" do
-      ruby_exe(fixture(__FILE__, "string_literal_raw.rb")).chomp.should == "frozen:false interned:false"
-    end
+  it "if file has no frozen_string_literal comment produce different mutable strings each time" do
+    ruby_exe(fixture(__FILE__, "string_literal_raw.rb")).chomp.should == "frozen:false interned:false"
   end
 
   it "if file has frozen_string_literal:true comment produce same frozen strings each time" do
diff --git a/spec/ruby/core/string/chilled_string_spec.rb b/spec/ruby/core/string/chilled_string_spec.rb
index 8de4fc421b4765..9f81b1af6d6597 100644
--- a/spec/ruby/core/string/chilled_string_spec.rb
+++ b/spec/ruby/core/string/chilled_string_spec.rb
@@ -3,8 +3,8 @@
 describe "chilled String" do
   guard -> { ruby_version_is "3.4" and !"test".equal?("test") } do
     describe "#frozen?" do
-      it "returns true" do
-        "chilled".frozen?.should == true
+      it "returns false" do
+        "chilled".frozen?.should == false
       end
     end
 
@@ -45,7 +45,7 @@
         input.should == "chilled-mutated"
       end
 
-      it "emits a warning on singleton_class creaation" do
+      it "emits a warning on singleton_class creation" do
         -> {
           "chilled".singleton_class
         }.should complain(/literal string will be frozen in the future/)
@@ -57,12 +57,14 @@
         }.should complain(/literal string will be frozen in the future/)
       end
 
-      it "raises FrozenError after the string was explictly frozen" do
+      it "raises FrozenError after the string was explicitly frozen" do
         input = "chilled"
         input.freeze
         -> {
+          -> {
           input << "mutated"
-        }.should raise_error(FrozenError)
+          }.should raise_error(FrozenError)
+        }.should_not complain(/literal string will be frozen in the future/)
       end
     end
   end
diff --git a/string.c b/string.c
index 9f7c163a812f50..d43a6391be836a 100644
--- a/string.c
+++ b/string.c
@@ -2453,6 +2453,9 @@ rb_check_lockedtmp(VALUE str)
 static inline void
 str_modifiable(VALUE str)
 {
+    if (CHILLED_STRING_P(str)) {
+        CHILLED_STRING_MUTATED(str);
+    }
     rb_check_lockedtmp(str);
     rb_check_frozen(str);
 }
@@ -3053,7 +3056,7 @@ rb_str_freeze(VALUE str)
 static VALUE
 str_uplus(VALUE str)
 {
-    if (OBJ_FROZEN(str)) {
+    if (OBJ_FROZEN(str) || CHILLED_STRING_P(str)) {
         return rb_str_dup(str);
     }
     else {
diff --git a/test/ruby/test_rubyoptions.rb b/test/ruby/test_rubyoptions.rb
index 76be9152a7eee8..d9b98be8baeb9e 100644
--- a/test/ruby/test_rubyoptions.rb
+++ b/test/ruby/test_rubyoptions.rb
@@ -1208,15 +1208,12 @@ def test_frozen_string_literal
   end
 
   def test_frozen_string_literal_debug
-    default_frozen = eval("'test'").frozen?
-
     with_debug_pat = /created at/
     wo_debug_pat = /can\'t modify frozen String: "\w+" \(FrozenError\)\n\z/
     frozen = [
       ["--enable-frozen-string-literal", true],
       ["--disable-frozen-string-literal", false],
     ]
-    frozen << [nil, false] unless default_frozen
 
     debugs = [
       ["--debug-frozen-string-literal", true],
diff --git a/test/ruby/test_string.rb b/test/ruby/test_string.rb
index ebe85dac826d6e..9bd86dfb78b695 100644
--- a/test/ruby/test_string.rb
+++ b/test/ruby/test_string.rb
@@ -3617,17 +3617,16 @@ def test_bytesplice
   def test_chilled_string
     chilled_string = eval('"chilled"')
 
-    # Chilled strings pretend to be frozen
-    assert_predicate chilled_string, :frozen?
+    assert_not_predicate chilled_string, :frozen?
 
     assert_not_predicate chilled_string.dup, :frozen?
-    assert_predicate chilled_string.clone, :frozen?
+    assert_not_predicate chilled_string.clone, :frozen?
 
     # @+ treat the original string as frozen
     assert_not_predicate(+chilled_string, :frozen?)
     assert_not_same chilled_string, +chilled_string
 
-    # @- the original string as mutable
+    # @- treat the original string as mutable
     assert_predicate(-chilled_string, :frozen?)
     assert_not_same chilled_string, -chilled_string
   end
diff --git a/yjit/bindgen/src/main.rs b/yjit/bindgen/src/main.rs
index a7473c1bf65724..94e821a05f45f9 100644
--- a/yjit/bindgen/src/main.rs
+++ b/yjit/bindgen/src/main.rs
@@ -223,6 +223,7 @@ fn main() {
         .allowlist_function("rb_float_div")
 
         // From internal/string.h
+        .allowlist_type("ruby_rstring_private_flags")
         .allowlist_function("rb_ec_str_resurrect")
         .allowlist_function("rb_str_concat_literals")
         .allowlist_function("rb_obj_as_string_result")
diff --git a/yjit/src/codegen.rs b/yjit/src/codegen.rs
index 747fa1769d2537..f426dd87cae9ff 100644
--- a/yjit/src/codegen.rs
+++ b/yjit/src/codegen.rs
@@ -5611,7 +5611,7 @@ fn jit_rb_str_uplus(
     let recv_opnd = asm.stack_pop(1);
     let recv_opnd = asm.load(recv_opnd);
     let flags_opnd = asm.load(Opnd::mem(64, recv_opnd, RUBY_OFFSET_RBASIC_FLAGS));
-    asm.test(flags_opnd, Opnd::Imm(RUBY_FL_FREEZE as i64));
+    asm.test(flags_opnd, Opnd::Imm(RUBY_FL_FREEZE as i64 | RSTRING_CHILLED as i64));
 
     let ret_label = asm.new_label("stack_ret");
 
diff --git a/yjit/src/cruby_bindings.inc.rs b/yjit/src/cruby_bindings.inc.rs
index d53e630a4a56fb..3a1de5f674798b 100644
--- a/yjit/src/cruby_bindings.inc.rs
+++ b/yjit/src/cruby_bindings.inc.rs
@@ -697,6 +697,8 @@ pub struct rb_call_data {
     pub ci: *const rb_callinfo,
     pub cc: *const rb_callcache,
 }
+pub const RSTRING_CHILLED: ruby_rstring_private_flags = 32768;
+pub type ruby_rstring_private_flags = u32;
 pub const RHASH_PASS_AS_KEYWORDS: ruby_rhash_flags = 8192;
 pub const RHASH_PROC_DEFAULT: ruby_rhash_flags = 16384;
 pub const RHASH_ST_TABLE_FLAG: ruby_rhash_flags = 32768;

From 9e9f1d9301b05604d475573ddd18d6bf5185466c Mon Sep 17 00:00:00 2001
From: Jean Boussier <byroot@ruby-lang.org>
Date: Mon, 8 Apr 2024 12:04:01 +0200
Subject: [PATCH 208/242] Precompute embedded string literals hash code
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With embedded strings we often have some space left in the slot, which
we can use to store the string Hash code.

It's probably only worth it for string literals, as they are the ones
likely to be used as hash keys.

We chose to store the Hash code right after the string terminator as to
make it easy/fast to compute, and not require one more union in RString.

```
compare-ruby: ruby 3.4.0dev (2024-04-22T06:32:21Z main f77618c1fa) [arm64-darwin23]
built-ruby: ruby 3.4.0dev (2024-04-22T10:13:03Z interned-string-ha.. 8a1a32331b) [arm64-darwin23]
last_commit=Precompute embedded string literals hash code

|            |compare-ruby|built-ruby|
|:-----------|-----------:|---------:|
|symbol      |     39.275M|   39.753M|
|            |           -|     1.01x|
|dyn_symbol  |     37.348M|   37.704M|
|            |           -|     1.01x|
|small_lit   |     29.514M|   33.948M|
|            |           -|     1.15x|
|frozen_lit  |     27.180M|   33.056M|
|            |           -|     1.22x|
|iseq_lit    |     27.391M|   32.242M|
|            |           -|     1.18x|
```

Co-Authored-By: Étienne Barrié <etienne.barrie@gmail.com>
---
 benchmark/hash_aref_str_lit.yml |  20 ++++++
 compile.c                       |   2 +-
 internal/string.h               |   1 +
 prism_compile.c                 |   2 +-
 ruby_parser.c                   |   2 +-
 string.c                        | 106 +++++++++++++++++++++++++++-----
 6 files changed, 114 insertions(+), 19 deletions(-)
 create mode 100644 benchmark/hash_aref_str_lit.yml

diff --git a/benchmark/hash_aref_str_lit.yml b/benchmark/hash_aref_str_lit.yml
new file mode 100644
index 00000000000000..ed8142bcf1eaf3
--- /dev/null
+++ b/benchmark/hash_aref_str_lit.yml
@@ -0,0 +1,20 @@
+prelude: |
+  # frozen_string_literal: true
+  hash = 10.times.to_h do |i|
+    [i, i]
+  end
+  dyn_sym = "dynamic_symbol".to_sym
+  binary = RubyVM::InstructionSequence.compile("# frozen_string_literal: true\n'iseq_load'").to_binary
+  iseq_literal_string = RubyVM::InstructionSequence.load_from_binary(binary).eval
+
+  hash[:some_symbol] = 1
+  hash[dyn_sym] = 2
+  hash["small"] = 3
+  hash["frozen_string_literal"] = 4
+  hash[iseq_literal_string] = 5
+benchmark:
+  symbol: hash[:some_symbol]
+  dyn_symbol: hash[dyn_sym]
+  small_lit: hash["small"]
+  frozen_lit: hash["frozen_string_literal"]
+  iseq_lit: hash[iseq_literal_string]
diff --git a/compile.c b/compile.c
index 0113d0e0ebbd0a..5fa35512c25ad3 100644
--- a/compile.c
+++ b/compile.c
@@ -13546,7 +13546,7 @@ ibf_load_object_string(const struct ibf_load *load, const struct ibf_object_head
 
     VALUE str;
     if (header->frozen && !header->internal) {
-        str = rb_enc_interned_str(ptr, len, rb_enc_from_index(encindex));
+        str = rb_enc_literal_str(ptr, len, rb_enc_from_index(encindex));
     }
     else {
         str = rb_enc_str_new(ptr, len, rb_enc_from_index(encindex));
diff --git a/internal/string.h b/internal/string.h
index 3333b3afc3c1d7..3533766ffb7b5c 100644
--- a/internal/string.h
+++ b/internal/string.h
@@ -80,6 +80,7 @@ VALUE rb_str_concat_literals(size_t num, const VALUE *strary);
 VALUE rb_str_eql(VALUE str1, VALUE str2);
 VALUE rb_id_quote_unprintable(ID);
 VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
+VALUE rb_enc_literal_str(const char *ptr, long len, rb_encoding *enc);
 
 struct rb_execution_context_struct;
 VALUE rb_ec_str_resurrect(struct rb_execution_context_struct *ec, VALUE str, bool chilled);
diff --git a/prism_compile.c b/prism_compile.c
index ea4c4fa054dea7..e1e16a00a7fe7b 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -292,7 +292,7 @@ parse_static_literal_string(rb_iseq_t *iseq, const pm_scope_node_t *scope_node,
         encoding = scope_node->encoding;
     }
 
-    VALUE value = rb_enc_interned_str((const char *) pm_string_source(string), pm_string_length(string), encoding);
+    VALUE value = rb_enc_literal_str((const char *) pm_string_source(string), pm_string_length(string), encoding);
     rb_enc_str_coderange(value);
 
     if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
diff --git a/ruby_parser.c b/ruby_parser.c
index 1dcdfd8e79ecd8..98541fc59757e1 100644
--- a/ruby_parser.c
+++ b/ruby_parser.c
@@ -921,7 +921,7 @@ rb_parser_build_script_lines_from(rb_parser_ary_t *lines)
 VALUE
 rb_str_new_parser_string(rb_parser_string_t *str)
 {
-    VALUE string = rb_enc_interned_str(str->ptr, str->len, str->enc);
+    VALUE string = rb_enc_literal_str(str->ptr, str->len, str->enc);
     rb_enc_str_coderange(string);
     return string;
 }
diff --git a/string.c b/string.c
index d43a6391be836a..98dbf1b7065b50 100644
--- a/string.c
+++ b/string.c
@@ -89,6 +89,9 @@ VALUE rb_cSymbol;
  *            another string (the shared root).
  * 3:     STR_CHILLED (will be frozen in a future version)
  *            The string appears frozen but can be mutated with a warning.
+ * 4:     STR_PRECOMPUTED_HASH
+ *            The string is embedded and has its precomputed hascode stored
+ *            after the terminator.
  * 5:     STR_SHARED_ROOT
  *            Other strings may point to the contents of this string. When this
  *            flag is set, STR_SHARED must not be set.
@@ -116,6 +119,7 @@ VALUE rb_cSymbol;
  */
 
 #define RUBY_MAX_CHAR_LEN 16
+#define STR_PRECOMPUTED_HASH FL_USER4
 #define STR_SHARED_ROOT FL_USER5
 #define STR_BORROWED FL_USER6
 #define STR_TMPLOCK FL_USER7
@@ -240,6 +244,11 @@ rb_str_size_as_embedded(VALUE str)
     else {
         real_size = sizeof(struct RString);
     }
+
+    if (FL_TEST_RAW(str, STR_PRECOMPUTED_HASH)) {
+        real_size += sizeof(st_index_t);
+    }
+
     return real_size;
 }
 
@@ -257,6 +266,7 @@ static VALUE str_new(VALUE klass, const char *ptr, long len);
 static void str_make_independent_expand(VALUE str, long len, long expand, const int termlen);
 static inline void str_modifiable(VALUE str);
 static VALUE rb_str_downcase(int argc, VALUE *argv, VALUE str);
+static inline VALUE str_alloc_embed(VALUE klass, size_t capa);
 
 static inline void
 str_make_independent(VALUE str)
@@ -334,7 +344,7 @@ mustnot_wchar(VALUE str)
 
 static int fstring_cmp(VALUE a, VALUE b);
 
-static VALUE register_fstring(VALUE str, bool copy);
+static VALUE register_fstring(VALUE str, bool copy, bool precompute_hash);
 
 const struct st_hash_type rb_fstring_hash_type = {
     fstring_cmp,
@@ -343,9 +353,42 @@ const struct st_hash_type rb_fstring_hash_type = {
 
 #define BARE_STRING_P(str) (!FL_ANY_RAW(str, FL_EXIVAR) && RBASIC_CLASS(str) == rb_cString)
 
+static inline st_index_t
+str_do_hash(VALUE str)
+{
+    st_index_t h = rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str));
+    int e = RSTRING_LEN(str) ? ENCODING_GET(str) : 0;
+    if (e && !is_ascii_string(str)) {
+        h = rb_hash_end(rb_hash_uint32(h, (uint32_t)e));
+    }
+    return h;
+}
+
+static VALUE
+str_precompute_hash(VALUE str)
+{
+    RUBY_ASSERT(!FL_TEST_RAW(str, STR_PRECOMPUTED_HASH));
+    RUBY_ASSERT(STR_EMBED_P(str));
+
+#if RUBY_DEBUG
+    size_t used_bytes = (RSTRING_LEN(str) + TERM_LEN(str));
+    size_t free_bytes = str_embed_capa(str) - used_bytes;
+    RUBY_ASSERT(free_bytes >= sizeof(st_index_t));
+#endif
+
+    typedef struct {char bytes[sizeof(st_index_t)];} unaligned_index;
+    union {st_index_t i; unaligned_index b;} u = {.i = str_do_hash(str)};
+    *(unaligned_index *)(RSTRING_END(str) + TERM_LEN(str)) = u.b;
+
+    FL_SET(str, STR_PRECOMPUTED_HASH);
+
+    return str;
+}
+
 struct fstr_update_arg {
     VALUE fstr;
     bool copy;
+    bool precompute_hash;
 };
 
 static int
@@ -370,8 +413,23 @@ fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t data, int exist
     else {
         if (FL_TEST_RAW(str, STR_FAKESTR)) {
             if (arg->copy) {
-                VALUE new_str = str_new(rb_cString, RSTRING(str)->as.heap.ptr, RSTRING(str)->len);
-                rb_enc_copy(new_str, str);
+                VALUE new_str;
+                long len = RSTRING_LEN(str);
+                long capa = len + sizeof(st_index_t);
+                int term_len = TERM_LEN(str);
+
+                if (arg->precompute_hash && STR_EMBEDDABLE_P(capa, term_len)) {
+                    new_str = str_alloc_embed(rb_cString, capa + term_len);
+                    memcpy(RSTRING_PTR(new_str), RSTRING_PTR(str), len);
+                    STR_SET_LEN(new_str, RSTRING_LEN(str));
+                    TERM_FILL(RSTRING_END(new_str), TERM_LEN(str));
+                    rb_enc_copy(new_str, str);
+                    str_precompute_hash(new_str);
+                }
+                else {
+                    new_str = str_new(rb_cString, RSTRING(str)->as.heap.ptr, RSTRING(str)->len);
+                    rb_enc_copy(new_str, str);
+                }
                 str = new_str;
             }
             else {
@@ -428,7 +486,7 @@ rb_fstring(VALUE str)
     if (!FL_TEST_RAW(str, FL_FREEZE | STR_NOFREE | STR_CHILLED))
         rb_str_resize(str, RSTRING_LEN(str));
 
-    fstr = register_fstring(str, FALSE);
+    fstr = register_fstring(str, false, false);
 
     if (!bare) {
         str_replace_shared_without_enc(str, fstr);
@@ -439,10 +497,12 @@ rb_fstring(VALUE str)
 }
 
 static VALUE
-register_fstring(VALUE str, bool copy)
+register_fstring(VALUE str, bool copy, bool precompute_hash)
 {
-    struct fstr_update_arg args;
-    args.copy = copy;
+    struct fstr_update_arg args = {
+        .copy = copy,
+        .precompute_hash = precompute_hash
+    };
 
     RB_VM_LOCK_ENTER();
     {
@@ -500,14 +560,14 @@ VALUE
 rb_fstring_new(const char *ptr, long len)
 {
     struct RString fake_str;
-    return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), FALSE);
+    return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), false, false);
 }
 
 VALUE
 rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc)
 {
     struct RString fake_str;
-    return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), FALSE);
+    return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), false, false);
 }
 
 VALUE
@@ -3658,12 +3718,15 @@ rb_str_prepend_multi(int argc, VALUE *argv, VALUE str)
 st_index_t
 rb_str_hash(VALUE str)
 {
-    st_index_t h = rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str));
-    int e = RSTRING_LEN(str) ? ENCODING_GET(str) : 0;
-    if (e && !is_ascii_string(str)) {
-        h = rb_hash_end(rb_hash_uint32(h, (uint32_t)e));
+    if (FL_TEST_RAW(str, STR_PRECOMPUTED_HASH)) {
+        typedef struct {char bytes[sizeof(st_index_t)];} unaligned_index;
+        st_index_t precomputed_hash = ((union {st_index_t i; unaligned_index b;} *)(RSTRING_END(str) + TERM_LEN(str)))->i;
+
+        RUBY_ASSERT(precomputed_hash == str_do_hash(str));
+        return precomputed_hash;
     }
-    return h;
+
+    return str_do_hash(str);
 }
 
 int
@@ -12133,7 +12196,7 @@ VALUE
 rb_interned_str(const char *ptr, long len)
 {
     struct RString fake_str;
-    return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), TRUE);
+    return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), true, false);
 }
 
 VALUE
@@ -12150,7 +12213,18 @@ rb_enc_interned_str(const char *ptr, long len, rb_encoding *enc)
     }
 
     struct RString fake_str;
-    return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), TRUE);
+    return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), true, false);
+}
+
+VALUE
+rb_enc_literal_str(const char *ptr, long len, rb_encoding *enc)
+{
+    if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) {
+        rb_enc_autoload(enc);
+    }
+
+    struct RString fake_str;
+    return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), true, true);
 }
 
 VALUE

From 1b8ba1551b26fac906998e34fd2af3f82b433469 Mon Sep 17 00:00:00 2001
From: Mike Dalessio <mike.dalessio@gmail.com>
Date: Fri, 24 May 2024 13:10:10 -0400
Subject: [PATCH 209/242] Allow compilation of C extensions with `-Wconversion`

C extension maintainers can now compile with this warning option and
the Ruby header files will generate no warnings.

[Feature #20507]
---
 include/ruby/internal/arithmetic/long.h      | 14 +++++++-------
 include/ruby/internal/arithmetic/long_long.h |  2 +-
 include/ruby/internal/arithmetic/st_data_t.h |  4 ++--
 include/ruby/internal/encoding/encoding.h    |  2 +-
 include/ruby/internal/memory.h               |  2 +-
 include/ruby/internal/special_consts.h       |  4 ++--
 6 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/include/ruby/internal/arithmetic/long.h b/include/ruby/internal/arithmetic/long.h
index 6b8fd8ffc31953..6c00dbceb71e32 100644
--- a/include/ruby/internal/arithmetic/long.h
+++ b/include/ruby/internal/arithmetic/long.h
@@ -114,11 +114,11 @@ RB_INT2FIX(long i)
 
     /* :NOTE: VALUE can be wider than long.  As j being unsigned, 2j+1 is fully
      * defined. Also it can be compiled into a single LEA instruction. */
-    const unsigned long j = i;
+    const unsigned long j = RBIMPL_CAST((unsigned long)i);
     const unsigned long k = (j << 1) + RUBY_FIXNUM_FLAG;
-    const long          l = k;
+    const long          l = RBIMPL_CAST((long)k);
     const SIGNED_VALUE  m = l; /* Sign extend */
-    const VALUE         n = m;
+    const VALUE         n = RBIMPL_CAST((VALUE)m);
 
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXNUM_P(n));
     return n;
@@ -166,7 +166,7 @@ rbimpl_fix2long_by_idiv(VALUE x)
     /* :NOTE: VALUE  can be wider  than long.  (x-1)/2 never  overflows because
      * RB_FIXNUM_P(x)  holds.   Also it  has  no  portability issue  like  y>>1
      * below. */
-    const SIGNED_VALUE y = x - RUBY_FIXNUM_FLAG;
+    const SIGNED_VALUE y = RBIMPL_CAST((SIGNED_VALUE)(x - RUBY_FIXNUM_FLAG));
     const SIGNED_VALUE z = y / 2;
     const long         w = RBIMPL_CAST((long)z);
 
@@ -193,7 +193,7 @@ rbimpl_fix2long_by_shift(VALUE x)
 
     /* :NOTE: VALUE can be wider than long.  If right shift is arithmetic, this
      * is noticeably faster than above. */
-    const SIGNED_VALUE y = x;
+    const SIGNED_VALUE y = RBIMPL_CAST((SIGNED_VALUE)x);
     const SIGNED_VALUE z = y >> 1;
     const long         w = RBIMPL_CAST((long)z);
 
@@ -252,7 +252,7 @@ static inline unsigned long
 rb_fix2ulong(VALUE x)
 {
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXNUM_P(x));
-    return rb_fix2long(x);
+    return RBIMPL_CAST((unsigned long)rb_fix2long(x));
 }
 
 /**
@@ -323,7 +323,7 @@ static inline VALUE
 rb_ulong2num_inline(unsigned long v)
 {
     if (RB_POSFIXABLE(v))
-        return RB_LONG2FIX(v);
+        return RB_LONG2FIX(RBIMPL_CAST((long)v));
     else
         return rb_uint2big(v);
 }
diff --git a/include/ruby/internal/arithmetic/long_long.h b/include/ruby/internal/arithmetic/long_long.h
index 65dec8729df623..aab455c83075aa 100644
--- a/include/ruby/internal/arithmetic/long_long.h
+++ b/include/ruby/internal/arithmetic/long_long.h
@@ -127,7 +127,7 @@ static inline unsigned LONG_LONG
 rb_num2ull_inline(VALUE x)
 {
     if (RB_FIXNUM_P(x))
-        return RB_FIX2LONG(x);
+        return RBIMPL_CAST((unsigned LONG_LONG)RB_FIX2LONG(x));
     else
         return rb_num2ull(x);
 }
diff --git a/include/ruby/internal/arithmetic/st_data_t.h b/include/ruby/internal/arithmetic/st_data_t.h
index 3bff4ffc0bff41..91776b3fce5af4 100644
--- a/include/ruby/internal/arithmetic/st_data_t.h
+++ b/include/ruby/internal/arithmetic/st_data_t.h
@@ -58,7 +58,7 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline VALUE
 RB_ST2FIX(st_data_t i)
 {
-    SIGNED_VALUE x = i;
+    SIGNED_VALUE x = RBIMPL_CAST((SIGNED_VALUE)i);
 
     if (x >= 0) {
         x &= RUBY_FIXNUM_MAX;
@@ -69,7 +69,7 @@ RB_ST2FIX(st_data_t i)
 
     RBIMPL_ASSERT_OR_ASSUME(RB_FIXABLE(x));
     unsigned long y = RBIMPL_CAST((unsigned long)x);
-    return RB_LONG2FIX(y);
+    return RB_LONG2FIX(RBIMPL_CAST((long)y));
 }
 
 #endif /* RBIMPL_ARITHMETIC_ST_DATA_T_H */
diff --git a/include/ruby/internal/encoding/encoding.h b/include/ruby/internal/encoding/encoding.h
index a680651a818073..a58f9f2b1524b5 100644
--- a/include/ruby/internal/encoding/encoding.h
+++ b/include/ruby/internal/encoding/encoding.h
@@ -80,7 +80,7 @@ enum ruby_encoding_consts {
 static inline void
 RB_ENCODING_SET_INLINED(VALUE obj, int encindex)
 {
-    VALUE f = /* upcast */ encindex;
+    VALUE f = /* upcast */ RBIMPL_CAST((VALUE)encindex);
 
     f <<= RUBY_ENCODING_SHIFT;
     RB_FL_UNSET_RAW(obj, RUBY_ENCODING_MASK);
diff --git a/include/ruby/internal/memory.h b/include/ruby/internal/memory.h
index 270cc1ac8b2e8a..64e850c65e0559 100644
--- a/include/ruby/internal/memory.h
+++ b/include/ruby/internal/memory.h
@@ -643,7 +643,7 @@ rbimpl_size_mul_or_raise(size_t x, size_t y)
 static inline void *
 rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize)
 {
-    const size_t total_size = rbimpl_size_mul_or_raise(count, elsize);
+    const size_t total_size = rbimpl_size_mul_or_raise(RBIMPL_CAST((size_t)count), elsize);
     const size_t cnt = (total_size + sizeof(VALUE) - 1) / sizeof(VALUE);
     return rb_alloc_tmp_buffer_with_count(store, total_size, cnt);
 }
diff --git a/include/ruby/internal/special_consts.h b/include/ruby/internal/special_consts.h
index dc0a6b41d6bad6..85579e33f012b8 100644
--- a/include/ruby/internal/special_consts.h
+++ b/include/ruby/internal/special_consts.h
@@ -156,7 +156,7 @@ RB_TEST(VALUE obj)
      *
      *  RTEST(v) can be 0 if and only if (v == Qfalse || v == Qnil).
      */
-    return obj & ~RUBY_Qnil;
+    return obj & RBIMPL_CAST((VALUE)~RUBY_Qnil);
 }
 
 RBIMPL_ATTR_CONST()
@@ -226,7 +226,7 @@ RB_NIL_OR_UNDEF_P(VALUE obj)
      *
      *  NIL_OR_UNDEF_P(v) can be true only when v is Qundef or Qnil.
      */
-    const VALUE mask = ~(RUBY_Qundef ^ RUBY_Qnil);
+    const VALUE mask = RBIMPL_CAST((VALUE)~(RUBY_Qundef ^ RUBY_Qnil));
     const VALUE common_bits = RUBY_Qundef & RUBY_Qnil;
     return (obj & mask) == common_bits;
 }

From ca2d229e6b31fc007204eed806b2b4af405c02fd Mon Sep 17 00:00:00 2001
From: Mike Dalessio <mike.dalessio@gmail.com>
Date: Mon, 27 May 2024 13:39:01 -0400
Subject: [PATCH 210/242] Test for compiling without warnings against public
 headers

Under compilers with WERRORFLAG, MakeMakefile.try_compile treats
warnings as errors, so we can use append_cflags to test whether the
public header files emit warnings with certain flags turned on.

[Regression test for feature #20507]
---
 ext/-test-/public_header_warnings/extconf.rb | 23 ++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 ext/-test-/public_header_warnings/extconf.rb

diff --git a/ext/-test-/public_header_warnings/extconf.rb b/ext/-test-/public_header_warnings/extconf.rb
new file mode 100644
index 00000000000000..f6a8a51f638cb5
--- /dev/null
+++ b/ext/-test-/public_header_warnings/extconf.rb
@@ -0,0 +1,23 @@
+#
+#  Under compilers with WERRORFLAG, MakeMakefile.try_compile treats warnings as errors, so we can
+#  use append_cflags to test whether the public header files emit warnings with certain flags turned
+#  on.
+#
+def check_append_cflags(flag, msg = nil)
+  msg ||= "flag #{flag} is not acceptable"
+  !$CFLAGS.include?(flag) or raise("flag #{flag} already present in $CFLAGS")
+  append_cflags(flag)
+  $CFLAGS.include?(flag) or raise(msg)
+end
+
+if %w[gcc clang].include?(RbConfig::CONFIG['CC'])
+  config_string("WERRORFLAG") or raise("expected WERRORFLAG to be defined")
+
+  # should be acceptable on all modern C compilers
+  check_append_cflags("-D_TEST_OK", "baseline compiler warning test failed")
+
+  # Feature #20507: Allow compilation of C extensions with -Wconversion
+  check_append_cflags("-Wconversion", "-Wconversion raising warnings in public headers")
+end
+
+create_makefile("-test-/public_header_warnings")

From ceeb9957c3ec932cdb911a5d1ff75e2c2bf16f17 Mon Sep 17 00:00:00 2001
From: Jean Boussier <jean.boussier@gmail.com>
Date: Tue, 28 May 2024 07:54:37 +0200
Subject: [PATCH 211/242] Make value_type.h compatible with -Wconversion

[Feature #20507]

This was missed from the initial commit.

```
../../.././include/ruby/internal/value_type.h:446:27: error: implicit conversion changes signedness: 'enum ruby_value_type' to 'int' [-Werror,-Wsign-conversion]
    rb_unexpected_type(v, t);
    ~~~~~~~~~~~~~~~~~~    ^
```
---
 include/ruby/internal/value_type.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/ruby/internal/value_type.h b/include/ruby/internal/value_type.h
index 977f60a0094d52..557f18813b3180 100644
--- a/include/ruby/internal/value_type.h
+++ b/include/ruby/internal/value_type.h
@@ -443,7 +443,7 @@ Check_Type(VALUE v, enum ruby_value_type t)
     }
 
   unexpected_type:
-    rb_unexpected_type(v, t);
+    rb_unexpected_type(v, RBIMPL_CAST((int)t));
 }
 
 #endif /* RBIMPL_VALUE_TYPE_H */

From 43798e0f6d72a8f1c624eba74c4a068ff9b21c84 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Tue, 28 May 2024 16:23:18 +0900
Subject: [PATCH 212/242] lldb: Show coderange

---
 misc/lldb_rb/utils.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/misc/lldb_rb/utils.py b/misc/lldb_rb/utils.py
index 1b0e4f9f2ab0bb..1d8e259f485de5 100644
--- a/misc/lldb_rb/utils.py
+++ b/misc/lldb_rb/utils.py
@@ -138,6 +138,16 @@ def inspect(self, val):
                 else:
                     self.result.write('[enc=%d] ' % encidx)
 
+                coderange = rval.flags & self.ruby_globals["RUBY_ENC_CODERANGE_MASK"]
+                if coderange == self.ruby_globals["RUBY_ENC_CODERANGE_7BIT"]:
+                    self.result.write('[7BIT] ')
+                elif coderange == self.ruby_globals["RUBY_ENC_CODERANGE_VALID"]:
+                    self.result.write('[VALID] ')
+                elif coderange == self.ruby_globals["RUBY_ENC_CODERANGE_BROKEN"]:
+                    self.result.write('[BROKEN] ')
+                else:
+                    self.result.write('[UNKNOWN] ')
+
                 ptr, len = self.string2cstr(val.Cast(tRString))
                 if len == 0:
                     self.result.write("(empty)\n")

From 0a92c9f2b011c4cfcd1b894dccfd4e8c36cadd57 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Tue, 28 May 2024 16:24:21 +0900
Subject: [PATCH 213/242] Set empty strings to ASCII-only

---
 string.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/string.c b/string.c
index 98dbf1b7065b50..83539ec8f409a9 100644
--- a/string.c
+++ b/string.c
@@ -931,6 +931,7 @@ empty_str_alloc(VALUE klass)
     RUBY_DTRACE_CREATE_HOOK(STRING, 0);
     VALUE str = str_alloc_embed(klass, 0);
     memset(RSTRING(str)->as.embed.ary, 0, str_embed_capa(str));
+    ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);
     return str;
 }
 
@@ -1552,6 +1553,7 @@ str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding)
             STR_SET_EMBED(str);
             memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig));
             STR_SET_LEN(str, RSTRING_LEN(orig));
+            ENC_CODERANGE_SET(str, ENC_CODERANGE(orig));
             TERM_FILL(RSTRING_END(str), TERM_LEN(orig));
         }
         else {
@@ -3199,7 +3201,11 @@ rb_str_set_len(VALUE str, long len)
     }
 
     int cr = ENC_CODERANGE(str);
-    if (cr == ENC_CODERANGE_UNKNOWN) {
+    if (len == 0) {
+        /* Empty string does not contain non-ASCII */
+        ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);
+    }
+    else if (cr == ENC_CODERANGE_UNKNOWN) {
         /* Leave unknown. */
     }
     else if (len > RSTRING_LEN(str)) {

From 7d144781a93df66379922717da711a09d1cf78ff Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Tue, 28 May 2024 16:59:51 +0900
Subject: [PATCH 214/242] [Bug #20512] Set coderange in `Range#each` of strings

---
 string.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/string.c b/string.c
index 83539ec8f409a9..ad1e76cdc93afe 100644
--- a/string.c
+++ b/string.c
@@ -5156,7 +5156,9 @@ rb_str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALU
 
         if (c > e || (excl && c == e)) return beg;
         for (;;) {
-            if ((*each)(rb_enc_str_new(&c, 1, enc), arg)) break;
+            VALUE str = rb_enc_str_new(&c, 1, enc);
+            ENC_CODERANGE_SET(str, RUBY_ENC_CODERANGE_7BIT);
+            if ((*each)(str, arg)) break;
             if (!excl && c == e) break;
             c++;
             if (excl && c == e) break;

From 6b3935250ef08e4983a63b0a8f88b411ba1ccdd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Rodr=C3=ADguez?= <deivid.rodriguez@riseup.net>
Date: Tue, 28 May 2024 15:38:14 +0200
Subject: [PATCH 215/242] [rubygems/rubygems] Bump COCs to latest Contributor
 Covenant version

https://github.com/rubygems/rubygems/commit/73794a95b9
---
 .../templates/newgem/CODE_OF_CONDUCT.md.tt    | 106 +++++++++++++-----
 1 file changed, 77 insertions(+), 29 deletions(-)

diff --git a/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt b/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
index 6a46aba8df62c5..67fe8cee798a7d 100644
--- a/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
+++ b/lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt
@@ -2,83 +2,131 @@
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
 
-We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
 
 ## Our Standards
 
-Examples of behavior that contributes to a positive environment for our community include:
+Examples of behavior that contributes to a positive environment for our
+community include:
 
 * Demonstrating empathy and kindness toward other people
 * Being respectful of differing opinions, viewpoints, and experiences
 * Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the overall community
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
 * Trolling, insulting or derogatory comments, and personal or political attacks
 * Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
 * Other conduct which could reasonably be considered inappropriate in a
   professional setting
 
 ## Enforcement Responsibilities
 
-Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
 
-Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
 
 ## Scope
 
-This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at <%= config[:email] %>. All complaints will be reviewed and investigated promptly and fairly.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
 
-All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
 
 ## Enforcement Guidelines
 
-Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
 
 ### 1. Correction
 
-**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
 
-**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
 
 ### 2. Warning
 
-**Community Impact**: A violation through a single incident or series of actions.
+**Community Impact**: A violation through a single incident or series of
+actions.
 
-**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
 
 ### 3. Temporary Ban
 
-**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
 
-**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
 
 ### 4. Permanent Ban
 
-**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
 
-**Consequence**: A permanent ban from any sort of public interaction within the community.
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
-available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
 
-Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
 
 For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

From 61e2916d1c297eeabcfeba4815cececff20db1dd Mon Sep 17 00:00:00 2001
From: Herwin <herwinw@users.noreply.github.com>
Date: Tue, 28 May 2024 16:02:52 +0200
Subject: [PATCH 216/242] [ruby/prism] Typo fix: poitive => positive

https://github.com/ruby/prism/commit/d13a05252d
---
 prism/util/pm_integer.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prism/util/pm_integer.c b/prism/util/pm_integer.c
index 137f7365369fcc..5b0f34465c5840 100644
--- a/prism/util/pm_integer.c
+++ b/prism/util/pm_integer.c
@@ -48,7 +48,7 @@ big_add(pm_integer_t *destination, pm_integer_t *left, pm_integer_t *right, uint
 
 /**
  * Internal use for karatsuba_multiply. Calculates `a - b - c` with the given
- * base. Assume a, b, c, a - b - c all to be poitive.
+ * base. Assume a, b, c, a - b - c all to be positive.
  * Return pm_integer_t with values allocated. Not normalized.
  */
 static void

From 31c9a3a1d330606493e5e70aec3cd1a36d8c61a0 Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Tue, 28 May 2024 23:19:33 +0900
Subject: [PATCH 217/242] [Bug #20438] Disallow "%\n" and "%\0"

---
 spec/ruby/core/string/modulo_spec.rb | 65 +++++++++++++++++++---------
 sprintf.c                            |  4 --
 test/ruby/test_sprintf.rb            | 11 +++--
 3 files changed, 49 insertions(+), 31 deletions(-)

diff --git a/spec/ruby/core/string/modulo_spec.rb b/spec/ruby/core/string/modulo_spec.rb
index bf96a8287462dc..9045afa263a63d 100644
--- a/spec/ruby/core/string/modulo_spec.rb
+++ b/spec/ruby/core/string/modulo_spec.rb
@@ -55,33 +55,48 @@
     -> { ("foo%" % [])}.should raise_error(ArgumentError)
   end
 
-  it "formats single % character before a newline as literal %" do
-    ("%\n" % []).should == "%\n"
-    ("foo%\n" % []).should == "foo%\n"
-    ("%\n.3f" % 1.2).should == "%\n.3f"
-  end
+  ruby_version_is ""..."3.4" do
+    it "formats single % character before a newline as literal %" do
+      ("%\n" % []).should == "%\n"
+      ("foo%\n" % []).should == "foo%\n"
+      ("%\n.3f" % 1.2).should == "%\n.3f"
+    end
 
-  it "formats single % character before a NUL as literal %" do
-    ("%\0" % []).should == "%\0"
-    ("foo%\0" % []).should == "foo%\0"
-    ("%\0.3f" % 1.2).should == "%\0.3f"
-  end
+    it "formats single % character before a NUL as literal %" do
+      ("%\0" % []).should == "%\0"
+      ("foo%\0" % []).should == "foo%\0"
+      ("%\0.3f" % 1.2).should == "%\0.3f"
+    end
 
-  it "raises an error if single % appears anywhere else" do
-    -> { (" % " % []) }.should raise_error(ArgumentError)
-    -> { ("foo%quux" % []) }.should raise_error(ArgumentError)
-  end
+    it "raises an error if single % appears anywhere else" do
+      -> { (" % " % []) }.should raise_error(ArgumentError)
+      -> { ("foo%quux" % []) }.should raise_error(ArgumentError)
+    end
 
-  it "raises an error if NULL or \\n appear anywhere else in the format string" do
-    begin
-      old_debug, $DEBUG = $DEBUG, false
+    it "raises an error if NULL or \\n appear anywhere else in the format string" do
+      begin
+        old_debug, $DEBUG = $DEBUG, false
 
+        -> { "%.\n3f" % 1.2 }.should raise_error(ArgumentError)
+        -> { "%.3\nf" % 1.2 }.should raise_error(ArgumentError)
+        -> { "%.\03f" % 1.2 }.should raise_error(ArgumentError)
+        -> { "%.3\0f" % 1.2 }.should raise_error(ArgumentError)
+      ensure
+        $DEBUG = old_debug
+      end
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "raises an ArgumentError if % is not followed by a conversion specifier" do
+      -> { "%" % [] }.should raise_error(ArgumentError)
+      -> { "%\n" % [] }.should raise_error(ArgumentError)
+      -> { "%\0" % [] }.should raise_error(ArgumentError)
+      -> { " % " % [] }.should raise_error(ArgumentError)
       -> { "%.\n3f" % 1.2 }.should raise_error(ArgumentError)
       -> { "%.3\nf" % 1.2 }.should raise_error(ArgumentError)
       -> { "%.\03f" % 1.2 }.should raise_error(ArgumentError)
       -> { "%.3\0f" % 1.2 }.should raise_error(ArgumentError)
-    ensure
-      $DEBUG = old_debug
     end
   end
 
@@ -125,8 +140,16 @@
     end
   end
 
-  it "replaces trailing absolute argument specifier without type with percent sign" do
-    ("hello %1$" % "foo").should == "hello %"
+  ruby_version_is ""..."3.4" do
+    it "replaces trailing absolute argument specifier without type with percent sign" do
+      ("hello %1$" % "foo").should == "hello %"
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "raises an ArgumentError if absolute argument specifier is followed by a conversion specifier" do
+      -> { "hello %1$" % "foo" }.should raise_error(ArgumentError)
+    end
   end
 
   it "raises an ArgumentError when given invalid argument specifiers" do
diff --git a/sprintf.c b/sprintf.c
index b2d89617aaf64b..98877d25d27d05 100644
--- a/sprintf.c
+++ b/sprintf.c
@@ -429,10 +429,6 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
             GETNUM(prec, precision);
             goto retry;
 
-          case '\n':
-          case '\0':
-            p--;
-            /* fall through */
           case '%':
             if (flags != FNONE) {
                 rb_raise(rb_eArgError, "invalid format character - %%");
diff --git a/test/ruby/test_sprintf.rb b/test/ruby/test_sprintf.rb
index c453ecd350b9b4..8cf2c63a203dc7 100644
--- a/test/ruby/test_sprintf.rb
+++ b/test/ruby/test_sprintf.rb
@@ -266,8 +266,8 @@ def test_invalid
     # Specifying the precision multiple times with negative star arguments:
     assert_raise(ArgumentError, "[ruby-core:11570]") {sprintf("%.*.*.*.*f", -1, -1, -1, 5, 1)}
 
-    # Null bytes after percent signs are removed:
-    assert_equal("%\0x hello", sprintf("%\0x hello"), "[ruby-core:11571]")
+    assert_raise(ArgumentError) {sprintf("%\0x hello")}
+    assert_raise(ArgumentError) {sprintf("%\nx hello")}
 
     assert_raise(ArgumentError, "[ruby-core:11573]") {sprintf("%.25555555555555555555555555555555555555s", "hello")}
 
@@ -279,10 +279,9 @@ def test_invalid
     assert_raise_with_message(ArgumentError, /unnumbered\(1\) mixed with numbered/) { sprintf("%1$*d", 3) }
     assert_raise_with_message(ArgumentError, /unnumbered\(1\) mixed with numbered/) { sprintf("%1$.*d", 3) }
 
-    verbose, $VERBOSE = $VERBOSE, nil
-    assert_nothing_raised { sprintf("", 1) }
-  ensure
-    $VERBOSE = verbose
+    assert_warning(/too many arguments/) do
+      sprintf("", 1)
+    end
   end
 
   def test_float

From 7f181268829dd5fbd5412cc0b6d79880a946bd6c Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 12:15:34 -0400
Subject: [PATCH 218/242] [ruby/prism] Fix line continuation heredoc dedent
 calculation

https://github.com/ruby/prism/commit/63b596df07
---
 prism/prism.c | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/prism/prism.c b/prism/prism.c
index c30d693d19248b..12bb55c4902805 100644
--- a/prism/prism.c
+++ b/prism/prism.c
@@ -12367,9 +12367,10 @@ parser_lex(pm_parser_t *parser) {
 
             // If we are immediately following a newline and we have hit the
             // terminator, then we need to return the ending of the heredoc.
-            if (!line_continuation && current_token_starts_line(parser)) {
+            if (current_token_starts_line(parser)) {
                 const uint8_t *start = parser->current.start;
-                if (start + ident_length <= parser->end) {
+
+                if (!line_continuation && (start + ident_length <= parser->end)) {
                     const uint8_t *newline = next_newline(start, parser->end - start);
                     const uint8_t *ident_end = newline;
                     const uint8_t *terminator_end = newline;
@@ -12525,11 +12526,8 @@ parser_lex(pm_parser_t *parser) {
                             }
 
                             parser->current.end = breakpoint + 1;
-
-                            if (!was_line_continuation) {
-                                pm_token_buffer_flush(parser, &token_buffer);
-                                LEX(PM_TOKEN_STRING_CONTENT);
-                            }
+                            pm_token_buffer_flush(parser, &token_buffer);
+                            LEX(PM_TOKEN_STRING_CONTENT);
                         }
 
                         // Otherwise we hit a newline and it wasn't followed by

From 8f84fbbf968a43c44b34ada601cf2b4a0bfa9d54 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 12:33:46 -0400
Subject: [PATCH 219/242] [PRISM] Enable
 TestSyntax#test_dedented_heredoc_continued_line

---
 test/.excludes-prism/TestSyntax.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestSyntax.rb b/test/.excludes-prism/TestSyntax.rb
index ed4ae4431885c8..926d2681d88f0c 100644
--- a/test/.excludes-prism/TestSyntax.rb
+++ b/test/.excludes-prism/TestSyntax.rb
@@ -1,3 +1,2 @@
-exclude(:test_dedented_heredoc_continued_line, "https://bugs.ruby-lang.org/issues/20503")
 exclude(:test_optional_self_reference, "https://bugs.ruby-lang.org/issues/20478")
 exclude(:test_keyword_self_reference, "https://bugs.ruby-lang.org/issues/20478")

From fd95ba255a413ff02cdc542dd16a2e2901387fc6 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 12:21:25 -0400
Subject: [PATCH 220/242] Make ensure first lineno the first line of the ensure

Previously, ensure ISEQs took their first line number from the
line number coming from the AST. However, if this is coming from
an empty `begin`..`end` inside of a method, this can be all of the
way back to the method declaration. Instead, this commit changes
it to be the first line number of the ensure block itself.

The first_lineno field is only accessible through manual ISEQ
compilation or through tracepoint. Either way, this will be more
accurate for targeting going forward.
---
 compile.c              | 2 +-
 test/ruby/test_iseq.rb | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compile.c b/compile.c
index 5fa35512c25ad3..3438d6a9fa4b96 100644
--- a/compile.c
+++ b/compile.c
@@ -8343,7 +8343,7 @@ compile_resbody(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node,
 static int
 compile_ensure(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node, int popped)
 {
-    const int line = nd_line(node);
+    const int line = nd_line(RNODE_ENSURE(node)->nd_ensr);
     const NODE *line_node = node;
     DECL_ANCHOR(ensr);
     const rb_iseq_t *ensure = NEW_CHILD_ISEQ(RNODE_ENSURE(node)->nd_ensr,
diff --git a/test/ruby/test_iseq.rb b/test/ruby/test_iseq.rb
index df4b6651b0216e..a47419253b4eaa 100644
--- a/test/ruby/test_iseq.rb
+++ b/test/ruby/test_iseq.rb
@@ -469,7 +469,7 @@ def test_each_child
                   ["<class:C>@1",
                     ["bar@10", ["block in bar@11",
                             ["block (2 levels) in bar@12"]]],
-                    ["foo@2", ["ensure in foo@2"],
+                    ["foo@2", ["ensure in foo@7"],
                               ["rescue in foo@4"]]],
                   ["<class:D>@17"]]
 
@@ -502,7 +502,7 @@ def test_trace_points
                                   [4, :line],
                                   [7, :line],
                                   [9, :return]]],
-                       [["ensure in foo@2", [[7, :line]]]],
+                       [["ensure in foo@7", [[7, :line]]]],
                        [["rescue in foo@4", [[5, :line],
                                              [5, :rescue]]]]]],
                    [["<class:D>@17", [[17, :class],

From 1eff5a98f1c83f37ca2daac1c52f3eb84f395acd Mon Sep 17 00:00:00 2001
From: Maxime Chevalier-Boisvert <maxime.chevalierboisvert@shopify.com>
Date: Tue, 28 May 2024 13:23:01 -0400
Subject: [PATCH 221/242] YJIT: limit size of call count stats dict (#10858)

* YJIT: limit size of call count stats dict

Someone reported that logs were getting bloated because the
ISEQ and C call count dicts were huge, since they include all
of the call sites. I wrote code on the Rust size to limit the
size of the dict to avoid this problem. The size limit is
hardcoded at 20, but I figure this is probably fine?

* Fix bug reported by Kokubun.
---
 yjit/src/stats.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/yjit/src/stats.rs b/yjit/src/stats.rs
index 6ffe28f12adcac..1f94c1939897ca 100644
--- a/yjit/src/stats.rs
+++ b/yjit/src/stats.rs
@@ -802,16 +802,31 @@ fn rb_yjit_gen_stats_dict(context: bool) -> VALUE {
             rb_hash_aset(hash, key, value);
         }
 
+        // Set method call counts in a Ruby dict
         fn set_call_counts(
             calls_hash: VALUE,
             method_name_to_idx: &mut Option<HashMap<String, usize>>,
             method_call_count: &mut Option<Vec<u64>>,
         ) {
             if let (Some(name_to_idx), Some(call_counts)) = (method_name_to_idx, method_call_count) {
+                // Create a list of (name, call_count) pairs
+                let mut pairs = Vec::new();
                 for (name, idx) in name_to_idx {
                     let count = call_counts[*idx];
+                    pairs.push((name, count));
+                }
+
+                // Sort the vectors by decreasing call counts
+                pairs.sort_by_key(|e| -(e.1 as i64));
+
+                // Cap the number of counts reported to avoid
+                // bloating log files, etc.
+                pairs.truncate(20);
+
+                // Add the pairs to the dict
+                for (name, call_count) in pairs {
                     let key = rust_str_to_sym(name);
-                    let value = VALUE::fixnum_from_usize(count as usize);
+                    let value = VALUE::fixnum_from_usize(call_count as usize);
                     unsafe { rb_hash_aset(calls_hash, key, value); }
                 }
             }

From e5759e412636c1224a27ede1fa3f7f97b51eae58 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 10:34:15 -0700
Subject: [PATCH 222/242] redmine-backporter.rb: Print help on wrong usage

---
 tool/redmine-backporter.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 44b44920d43abb..da3b71a6403eda 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -35,11 +35,11 @@ module Readline; end
 $openuri_options = {}
 $openuri_options[:ssl_verify_mode] = OpenSSL::SSL::VERIFY_NONE unless ssl_verify
 
-TARGET_VERSION = target_version || ENV['TARGET_VERSION'] || (raise 'need to specify TARGET_VERSION')
+TARGET_VERSION = target_version || ENV['TARGET_VERSION'] || (puts opts.help; raise 'need to specify TARGET_VERSION')
 RUBY_REPO_PATH = repo_path || ENV['RUBY_REPO_PATH']
 BACKPORT_CF_KEY = 'cf_5'
 STATUS_CLOSE = 5
-REDMINE_API_KEY = api_key || ENV['REDMINE_API_KEY'] || (raise 'need to specify REDMINE_API_KEY')
+REDMINE_API_KEY = api_key || ENV['REDMINE_API_KEY'] || (puts opts.help; raise 'need to specify REDMINE_API_KEY')
 REDMINE_BASE = 'https://bugs.ruby-lang.org'
 
 @query = {

From db7c385897ac3ea6ce7d144385a5bd7f0605449c Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 10:39:39 -0700
Subject: [PATCH 223/242] redmine-backporter.rb: Get rid of VERSION

that has never been utilized
---
 tool/redmine-backporter.rb | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index da3b71a6403eda..3f5c9af2714d5e 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -16,18 +16,15 @@
   module Readline; end
 end
 
-VERSION = '0.0.1'
-
 opts = OptionParser.new
 target_version = nil
 repo_path = nil
 api_key = nil
 ssl_verify = true
 opts.on('-k REDMINE_API_KEY', '--key=REDMINE_API_KEY', 'specify your REDMINE_API_KEY') {|v| api_key = v}
-opts.on('-t TARGET_VERSION', '--target=TARGET_VARSION', /\A\d(?:\.\d)+\z/, 'specify target version (ex: 2.1)') {|v| target_version = v}
+opts.on('-t TARGET_VERSION', '--target=TARGET_VARSION', /\A\d(?:\.\d)+\z/, 'specify target version (ex: 3.1)') {|v| target_version = v}
 opts.on('-r RUBY_REPO_PATH', '--repository=RUBY_REPO_PATH', 'specify repository path') {|v| repo_path = v}
 opts.on('--[no-]ssl-verify', TrueClass, 'use / not use SSL verify') {|v| ssl_verify = v}
-opts.version = VERSION
 opts.parse!(ARGV)
 
 http_options = {use_ssl: true}
@@ -294,7 +291,7 @@ def status_char(obj)
 console = IO.console
 row, = console.winsize
 @query['limit'] = row - 2
-puts "Backporter #{VERSION}".color(bold: true) + " for #{TARGET_VERSION}"
+puts "Redmine Backporter".color(bold: true) + " for Ruby #{TARGET_VERSION}"
 
 class CommandSyntaxError < RuntimeError; end
 commands = {

From 450e9d2495f1c4078debc115dfcd5880da06efd9 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 10:42:06 -0700
Subject: [PATCH 224/242] redmine-backporter.rb: Migrate Readline to Reline

instead of using a local Readline port as a fallback
---
 tool/redmine-backporter.rb | 82 +-------------------------------------
 1 file changed, 2 insertions(+), 80 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 3f5c9af2714d5e..99c3f430466a16 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -10,11 +10,7 @@
 require 'abbrev'
 require 'pp'
 require 'shellwords'
-begin
-  require 'readline'
-rescue LoadError
-  module Readline; end
-end
+require 'reline'
 
 opts = OptionParser.new
 target_version = nil
@@ -159,80 +155,6 @@ def more(sio)
   end
 end
 
-class << Readline
-  def readline(prompt = '')
-    console = IO.console
-    console.binmode
-    _, lx = console.winsize
-    if /mswin|mingw/ =~ RUBY_PLATFORM or /^(?:vt\d\d\d|xterm)/i =~ ENV["TERM"]
-      cls = "\r\e[2K"
-    else
-      cls = "\r" << (" " * lx)
-    end
-    cls << "\r" << prompt
-    console.print prompt
-    console.flush
-    line = ''
-    while true
-      case c = console.getch
-      when "\r", "\n"
-        puts
-        HISTORY << line
-        return line
-      when "\C-?", "\b" # DEL/BS
-        print "\b \b" if line.chop!
-      when "\C-u"
-        print cls
-        line.clear
-      when "\C-d"
-        return nil if line.empty?
-        line << c
-      when "\C-p"
-        HISTORY.pos -= 1
-        line = HISTORY.current
-        print cls
-        print line
-      when "\C-n"
-        HISTORY.pos += 1
-        line = HISTORY.current
-        print cls
-        print line
-      else
-        if c >= " "
-          print c
-          line << c
-        end
-      end
-    end
-  end
-
-  HISTORY = []
-  def HISTORY.<<(val)
-    HISTORY.push(val)
-    @pos = self.size
-    self
-  end
-  def HISTORY.pos
-    @pos ||= 0
-  end
-  def HISTORY.pos=(val)
-    @pos = val
-    if @pos < 0
-      @pos = -1
-    elsif @pos >= self.size
-      @pos = self.size
-    end
-  end
-  def HISTORY.current
-    @pos ||= 0
-    if @pos < 0 || @pos >= self.size
-      ''
-    else
-      self[@pos]
-    end
-  end
-end unless defined?(Readline.readline)
-
 def find_svn_log(pattern)
   `svn log --xml --stop-on-copy --search="#{pattern}" #{RUBY_REPO_PATH}`
 end
@@ -568,7 +490,7 @@ class << @changesets
 @changesets = nil
 while true
   begin
-    l = Readline.readline "#{('#' + @issue.to_s).color(bold: true) if @issue}> "
+    l = Reline.readline "#{('#' + @issue.to_s).color(bold: true) if @issue}> "
   rescue Interrupt
     break
   end

From 3f256dc66a3b9f67d4af69e76a645999352a3650 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 10:47:51 -0700
Subject: [PATCH 225/242] redmine-backporter.rb: Drop SVN support

---
 tool/redmine-backporter.rb | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 99c3f430466a16..69affd842c60b3 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -155,10 +155,6 @@ def more(sio)
   end
 end
 
-def find_svn_log(pattern)
-  `svn log --xml --stop-on-copy --search="#{pattern}" #{RUBY_REPO_PATH}`
-end
-
 def find_git_log(pattern)
   `git #{RUBY_REPO_PATH ? "-C #{RUBY_REPO_PATH.shellescape}" : ""} log --grep="#{pattern}"`
 end
@@ -295,9 +291,6 @@ class CommandSyntaxError < RuntimeError; end
   "rel" => proc{|args|
     # this feature requires custom redmine which allows add_related_issue API
     case args
-    when /\Ar?(\d+)\z/ # SVN
-      rev = $1
-      uri = URI("#{REDMINE_BASE}/projects/ruby-master/repository/trunk/revisions/#{rev}/issues.json")
     when /\A\h{7,40}\z/ # Git
       rev = args
       uri = URI("#{REDMINE_BASE}/projects/ruby-master/repository/git/revisions/#{rev}/issues.json")
@@ -355,15 +348,8 @@ class << @changesets
       next
     end
 
-    if rev
-    elsif system("svn info #{RUBY_REPO_PATH&.shellescape}", %i(out err) => IO::NULL) # SVN
-      if (log = find_svn_log("##@issue]")) && (/revision="(?<rev>\d+)/ =~ log)
-        rev = "r#{rev}"
-      end
-    else # Git
-      if log = find_git_log("##@issue]")
-        /^commit (?<rev>\h{40})$/ =~ log
-      end
+    if rev.nil? && log = find_git_log("##@issue]")
+      /^commit (?<rev>\h{40})$/ =~ log
     end
     if log && rev
       str = log[/merge revision\(s\) ([^:]+)(?=:)/]

From 07f494ccad5505b3c82f4d0d634e4a517469a8c2 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 12:36:20 -0400
Subject: [PATCH 226/242] [PRISM] Enable TestISeq#test_each_child

---
 test/.excludes-prism/TestISeq.rb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/.excludes-prism/TestISeq.rb b/test/.excludes-prism/TestISeq.rb
index 499ae2e53dbe33..d6750fda3602d1 100644
--- a/test/.excludes-prism/TestISeq.rb
+++ b/test/.excludes-prism/TestISeq.rb
@@ -1,2 +1 @@
-exclude(:test_each_child, "https://bugs.ruby-lang.org/issues/20479")
 exclude(:test_trace_points, "https://bugs.ruby-lang.org/issues/20479")

From 22536148e217bb2fa48ea242a3310936fde1f021 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 12:41:05 -0400
Subject: [PATCH 227/242] [PRISM] Use PUSH_SYNTHETIC_PUTNIL for all optional
 statement bodies

---
 prism_compile.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/prism_compile.c b/prism_compile.c
index e1e16a00a7fe7b..4d06aa2ebe4485 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -4257,7 +4257,7 @@ pm_compile_rescue(rb_iseq_t *iseq, const pm_begin_node_t *cast, const pm_line_co
         PM_COMPILE_NOT_POPPED((const pm_node_t *) cast->statements);
     }
     else {
-        PUSH_INSN(ret, *node_location, putnil);
+        PUSH_SYNTHETIC_PUTNIL(ret, iseq);
     }
 
     ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
@@ -5310,7 +5310,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
                 PM_COMPILE((const pm_node_t *) cast->statements);
             }
             else if (!popped) {
-                PUSH_INSN(ret, location, putnil);
+                PUSH_SYNTHETIC_PUTNIL(ret, iseq);
             }
         }
         return;
@@ -5605,7 +5605,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
                     pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
                 }
                 else if (!popped) {
-                    PUSH_INSN(body_seq, location, putnil);
+                    PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
                 }
 
                 PUSH_INSNL(body_seq, location, jump, end_label);
@@ -5754,7 +5754,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
                     pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
                 }
                 else if (!popped) {
-                    PUSH_INSN(body_seq, clause_location, putnil);
+                    PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
                 }
 
                 PUSH_INSNL(body_seq, clause_location, jump, end_label);
@@ -5902,7 +5902,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
                 PM_COMPILE_INTO_ANCHOR(body_seq, (const pm_node_t *) in_node->statements);
             }
             else if (!popped) {
-                PUSH_INSN(body_seq, in_location, putnil);
+                PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
             }
 
             PUSH_INSNL(body_seq, in_location, jump, end_label);
@@ -6238,7 +6238,7 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
             PM_COMPILE((const pm_node_t *) (cast->statements));
         }
         else {
-            PUSH_INSN(ret, location, putnil);
+            PUSH_SYNTHETIC_PUTNIL(ret, iseq);
         }
 
         if (popped) PUSH_INSN(ret, location, pop);

From 9efb8825a323255ac7444c574d99c41f86c63814 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 13:01:15 -0400
Subject: [PATCH 228/242] [PRISM] Update BEGIN node line number based on empty
 statements and rescue

---
 prism_compile.c | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/prism_compile.c b/prism_compile.c
index 4d06aa2ebe4485..7880e6d231e7ed 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -5059,8 +5059,24 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
     const pm_line_column_t location = PM_NODE_START_LINE_COLUMN(parser, node);
     int lineno = (int) location.line;
 
-    if (!PM_NODE_TYPE_P(node, PM_RETURN_NODE) || !PM_NODE_FLAG_P(node, PM_RETURN_NODE_FLAGS_REDUNDANT) || ((const pm_return_node_t *) node)->arguments != NULL) {
+    if (PM_NODE_TYPE_P(node, PM_RETURN_NODE) && PM_NODE_FLAG_P(node, PM_RETURN_NODE_FLAGS_REDUNDANT) && ((const pm_return_node_t *) node)->arguments == NULL) {
+        // If the node that we're compiling is a return node that is redundant,
+        // then it cannot be considered a line node because the other parser
+        // eliminates it from the parse tree. In this case we must replicate
+        // this behavior.
+    } else {
+        if (PM_NODE_TYPE_P(node, PM_BEGIN_NODE) && (((const pm_begin_node_t *) node)->statements == NULL) && (((const pm_begin_node_t *) node)->rescue_clause != NULL)) {
+            // If this node is a begin node and it has empty statements and also
+            // has a rescue clause, then the other parser considers it as
+            // starting on the same line as the rescue, as opposed to the
+            // location of the begin keyword. We replicate that behavior here.
+            lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((const pm_begin_node_t *) node)->rescue_clause).line;
+        }
+
         if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_NEWLINE) && ISEQ_COMPILE_DATA(iseq)->last_line != lineno) {
+            // If this node has the newline flag set and it is on a new line
+            // from the previous nodes that have been compiled for this ISEQ,
+            // then we need to emit a newline event.
             int event = RUBY_EVENT_LINE;
 
             ISEQ_COMPILE_DATA(iseq)->last_line = lineno;

From a7eb3d077b4a0e4582380540830b9ef994f2a6a2 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 13:02:02 -0400
Subject: [PATCH 229/242] [PRISM] Enable TestISeq#test_trace_points

---
 test/.excludes-prism/TestISeq.rb | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 test/.excludes-prism/TestISeq.rb

diff --git a/test/.excludes-prism/TestISeq.rb b/test/.excludes-prism/TestISeq.rb
deleted file mode 100644
index d6750fda3602d1..00000000000000
--- a/test/.excludes-prism/TestISeq.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_trace_points, "https://bugs.ruby-lang.org/issues/20479")

From 2608f2a23bb037f2b79e76c83d4b70716f039d1a Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 11:41:04 -0700
Subject: [PATCH 230/242] redmine-backporter.rb: Fix #color for Ruby 3 splat

color(*PRIORITIES['Immediate']) didn't work with Ruby 3.
---
 tool/redmine-backporter.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 69affd842c60b3..47310c5abdde03 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -63,12 +63,12 @@
 }
 
 class String
-  def color(fore=nil, back=nil, bold: false, underscore: false)
+  def color(fore=nil, back=nil, opts={}, bold: false, underscore: false)
     seq = ""
-    if bold
+    if bold || opts[:bold]
       seq << "\e[1m"
     end
-    if underscore
+    if underscore || opts[:underscore]
       seq << "\e[2m"
     end
     if fore

From 13307cd9444d17dff2da1d0ff03efcede23ad88d Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 11:46:01 -0700
Subject: [PATCH 231/242] redmine-backporter.rb: Highlight closed tickets

---
 tool/redmine-backporter.rb | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 47310c5abdde03..6c3477b79bb6b7 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -221,10 +221,11 @@ class CommandSyntaxError < RuntimeError; end
     @issues = issues = res["issues"]
     from = res["offset"] + 1
     total = res["total_count"]
+    closed = issues.count { |x, _| x["status"]["name"] == "Closed" }
     to = from + issues.size - 1
-    puts "#{from}-#{to} / #{total}"
+    puts "#{from}-#{to} / #{total} (closed: #{closed})"
     issues.each_with_index do |x, i|
-      id = "##{x["id"]}".color(*PRIORITIES[x["priority"]["name"]])
+      id = "##{x["id"]}".color(*PRIORITIES[x["priority"]["name"]], bold: x["status"]["name"] == "Closed")
       puts "#{'%2d' % i} #{id} #{x["priority"]["name"][0]} #{status_char(x["status"])} #{x["subject"][0,80]}"
     end
   },

From bc3199bb298d9d29d66aedeb1139715893ebfea8 Mon Sep 17 00:00:00 2001
From: Kevin Newton <kddnewton@gmail.com>
Date: Tue, 28 May 2024 14:49:39 -0400
Subject: [PATCH 232/242] [PRISM] Enable TestAssignmentGen#test_assignment

---
 prism_compile.c                           | 12 +++++++++---
 test/.excludes-prism/TestAssignmentGen.rb |  1 -
 2 files changed, 9 insertions(+), 4 deletions(-)
 delete mode 100644 test/.excludes-prism/TestAssignmentGen.rb

diff --git a/prism_compile.c b/prism_compile.c
index 7880e6d231e7ed..022305effe42dc 100644
--- a/prism_compile.c
+++ b/prism_compile.c
@@ -4036,9 +4036,15 @@ pm_compile_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *cons
         //
         //     for i, j in []; end
         //
-        if (state != NULL) state->position--;
+        size_t before_position;
+        if (state != NULL) {
+            before_position = state->position;
+            state->position--;
+        }
+
         pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
-        if (state != NULL) state->position++;
+        if (state != NULL) state->position = before_position;
+
         break;
       }
       default:
@@ -4095,7 +4101,7 @@ pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR
     if (state == NULL) state = &target_state;
 
     size_t base_position = state->position;
-    size_t splat_position = has_rest ? 1 : 0;
+    size_t splat_position = (has_rest || has_posts) ? 1 : 0;
 
     // Next, we'll iterate through all of the leading targets.
     for (size_t index = 0; index < lefts->size; index++) {
diff --git a/test/.excludes-prism/TestAssignmentGen.rb b/test/.excludes-prism/TestAssignmentGen.rb
deleted file mode 100644
index 5f3bb12ef7c22d..00000000000000
--- a/test/.excludes-prism/TestAssignmentGen.rb
+++ /dev/null
@@ -1 +0,0 @@
-exclude(:test_assignment, "https://github.com/ruby/prism/issues/2370")

From 2c8b2f5b55f506913397d0cf4ecf3d80e9bf785d Mon Sep 17 00:00:00 2001
From: Darren Kavanagh <dkav@users.noreply.github.com>
Date: Thu, 16 May 2024 10:22:35 -0700
Subject: [PATCH 233/242] [rubygems/rubygems] Clarify BUNDLE_USER_CONFIG is a
 file

https://github.com/rubygems/rubygems/commit/0b284fc88c
---
 lib/bundler/man/bundle-config.1      | 2 +-
 lib/bundler/man/bundle-config.1.ronn | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/bundler/man/bundle-config.1 b/lib/bundler/man/bundle-config.1
index a207dbbcaa3a9e..2de52ee375eaa4 100644
--- a/lib/bundler/man/bundle-config.1
+++ b/lib/bundler/man/bundle-config.1
@@ -307,7 +307,7 @@ Any \fB\.\fR characters in a host name are mapped to a double underscore (\fB__\
 .P
 This means that if you have a gem server named \fBmy\.gem\-host\.com\fR, you'll need to use the \fBBUNDLE_MY__GEM___HOST__COM\fR variable to configure credentials for it through ENV\.
 .SH "CONFIGURE BUNDLER DIRECTORIES"
-Bundler's home, config, cache and plugin directories are able to be configured through environment variables\. The default location for Bundler's home directory is \fB~/\.bundle\fR, which all directories inherit from by default\. The following outlines the available environment variables and their default values
+Bundler's home, cache and plugin directories and config file can be configured through environment variables\. The default location for Bundler's home directory is \fB~/\.bundle\fR, which all directories inherit from by default\. The following outlines the available environment variables and their default values
 .IP "" 4
 .nf
 BUNDLE_USER_HOME : $HOME/\.bundle
diff --git a/lib/bundler/man/bundle-config.1.ronn b/lib/bundler/man/bundle-config.1.ronn
index 7e5f458fb288a8..1a0ec2a5dc5175 100644
--- a/lib/bundler/man/bundle-config.1.ronn
+++ b/lib/bundler/man/bundle-config.1.ronn
@@ -397,7 +397,7 @@ through ENV.
 
 ## CONFIGURE BUNDLER DIRECTORIES
 
-Bundler's home, config, cache and plugin directories are able to be configured
+Bundler's home, cache and plugin directories and config file can be configured
 through environment variables. The default location for Bundler's home directory is
 `~/.bundle`, which all directories inherit from by default. The following
 outlines the available environment variables and their default values

From 78732753261eb4c744620125505866e067e293dd Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 13:37:52 -0700
Subject: [PATCH 234/242] redmine-backporter.rb: Use commit: prefix

---
 tool/redmine-backporter.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 6c3477b79bb6b7..eb917a9d81e4bf 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -356,9 +356,9 @@ class << @changesets
       str = log[/merge revision\(s\) ([^:]+)(?=:)/]
       if str
         str.insert(5, "d")
-        str = "ruby_#{TARGET_VERSION.tr('.','_')} #{rev} #{str}."
+        str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev} #{str}."
       else
-        str = "ruby_#{TARGET_VERSION.tr('.','_')} #{rev}."
+        str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev}."
       end
       if notes
         str << "\n"

From 7a860bacee34d082f9731f5edbeea49ee405a268 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 13:51:45 -0700
Subject: [PATCH 235/242] merger.rb: Drop SVN support

---
 tool/merger.rb | 127 ++++++++++---------------------------------------
 1 file changed, 26 insertions(+), 101 deletions(-)

diff --git a/tool/merger.rb b/tool/merger.rb
index 0d9957074fbc9b..9aac5e85695801 100755
--- a/tool/merger.rb
+++ b/tool/merger.rb
@@ -2,9 +2,8 @@
 # -*- ruby -*-
 exec "${RUBY-ruby}" "-x" "$0" "$@" && [ ] if false
 #!ruby
-# This needs ruby 2.0, Subversion and Git.
-# As a Ruby committer, run this in an SVN repository
-# to commit a change.
+# This needs ruby 2.0 and Git.
+# As a Ruby committer, run this in a git repository to commit a change.
 
 require 'tempfile'
 require 'net/http'
@@ -15,13 +14,7 @@
 ORIGIN = 'git@git.ruby-lang.org:ruby.git'
 GITHUB = 'git@github.com:ruby/ruby.git'
 
-module Merger
-  REPOS = 'svn+ssh://svn@ci.ruby-lang.org/ruby/'
-end
-
-class << Merger
-  include Merger
-
+class << Merger = Object.new
   def help
     puts <<-HELP
 \e[1msimple backport\e[0m
@@ -69,11 +62,7 @@ def interactive(str, editfile = nil)
   def version_up(teeny: false)
     now = Time.now
     now = now.localtime(9*60*60) # server is Japan Standard Time +09:00
-    if svn_mode?
-      system('svn', 'revert', 'version.h')
-    else
-      system('git', 'checkout', 'HEAD', 'version.h')
-    end
+    system('git', 'checkout', 'HEAD', 'version.h')
     v, pl = version
 
     if teeny
@@ -129,31 +118,10 @@ def tag(relname)
     end
     tagname = "v#{v.join('_')}#{("_#{pl}" if v[0] < "2" || (v[0] == "2" && v[1] < "1") || /^(?:preview|rc)/ =~ pl)}"
 
-    if svn_mode?
-      if relname
-        branch_url = `svn info`[/URL: (.*)/, 1]
-      else
-        branch_url = "#{REPOS}branches/ruby_"
-        if v[0] < '2' || (v[0] == '2' && v[1] < '1')
-          abort 'patchlevel must be greater than 0 for patch release' if pl == '0'
-          branch_url << v.join('_')
-        else
-          abort 'teeny must be greater than 0 for patch release' if v[2] == '0'
-          branch_url << v.join('_').sub(/_\d+\z/, '')
-        end
-      end
-      tag_url = "#{REPOS}tags/#{tagname}"
-      system('svn', 'info', tag_url, out: IO::NULL, err: IO::NULL)
-      if $?.success?
-        abort 'specfied tag already exists. check tag name and remove it if you want to force re-tagging'
-      end
-      execute('svn', 'cp', '-m', "add tag #{tagname}", branch_url, tag_url, interactive: true)
-    else
-      unless execute('git', 'tag', tagname)
-        abort 'specfied tag already exists. check tag name and remove it if you want to force re-tagging'
-      end
-      execute('git', 'push', ORIGIN, tagname, interactive: true)
+    unless execute('git', 'tag', tagname)
+      abort 'specfied tag already exists. check tag name and remove it if you want to force re-tagging'
     end
+    execute('git', 'push', ORIGIN, tagname, interactive: true)
   end
 
   def remove_tag(relname)
@@ -173,64 +141,33 @@ def remove_tag(relname)
       tagname = relname
     end
 
-    if svn_mode?
-      tag_url = "#{REPOS}tags/#{tagname}"
-      execute('svn', 'rm', '-m', "remove tag #{tagname}", tag_url, interactive: true)
-    else
-      execute('git', 'tag', '-d', tagname)
-      execute('git', 'push', ORIGIN, ":#{tagname}", interactive: true)
-      execute('git', 'push', GITHUB, ":#{tagname}", interactive: true)
-    end
+    execute('git', 'tag', '-d', tagname)
+    execute('git', 'push', ORIGIN, ":#{tagname}", interactive: true)
+    execute('git', 'push', GITHUB, ":#{tagname}", interactive: true)
   end
 
   def update_revision_h
-    if svn_mode?
-      execute('svn', 'up')
-    end
     execute('ruby tool/file2lastrev.rb --revision.h . > revision.tmp')
     execute('tool/ifchange', '--timestamp=.revision.time', 'revision.h', 'revision.tmp')
     execute('rm', '-f', 'revision.tmp')
   end
 
   def stat
-    if svn_mode?
-      `svn stat`
-    else
-      `git status --short`
-    end
+    `git status --short`
   end
 
   def diff(file = nil)
-    if svn_mode?
-      command = %w[svn diff --diff-cmd=diff -x -upw]
-    else
-      command = %w[git diff --color HEAD]
-    end
+    command = %w[git diff --color HEAD]
     IO.popen(command + [file].compact, &:read)
   end
 
   def commit(file)
-    if svn_mode?
-      begin
-        execute('svn', 'ci', '-F', file)
-        execute('svn', 'update') # svn ci doesn't update revision info on working copy
-      ensure
-        execute('rm', '-f', 'subversion.commitlog')
-      end
-    else
-      current_branch = IO.popen(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], &:read).strip
-      execute('git', 'add', '.') &&
-        execute('git', 'commit', '-F', file)
-    end
+    current_branch = IO.popen(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], &:read).strip
+    execute('git', 'add', '.') && execute('git', 'commit', '-F', file)
   end
 
   private
 
-  def svn_mode?
-    return @svn_mode if defined?(@svn_mode)
-    @svn_mode = system("svn info", %i(out err) => IO::NULL)
-  end
-
   # Prints the version of Ruby found in version.h
   def version
     v = p = nil
@@ -303,8 +240,6 @@ def execute(*cmd, interactive: false)
   revs.each do |rev|
     git_rev = nil
     case rev
-    when /\A\d{1,6}\z/
-      svn_rev = rev
     when /\A\h{7,40}\z/
       git_rev = rev
     when nil then
@@ -315,30 +250,20 @@ def execute(*cmd, interactive: false)
       exit
     end
 
-    # Merge revision from Git patch or SVN
-    if git_rev
-      git_uri = "https://git.ruby-lang.org/ruby.git/patch/?id=#{git_rev}"
-      resp = Net::HTTP.get_response(URI(git_uri))
-      if resp.code != '200'
-        abort "'#{git_uri}' returned status '#{resp.code}':\n#{resp.body}"
-      end
-      patch = resp.body.sub(/^diff --git a\/version\.h b\/version\.h\nindex .*\n--- a\/version\.h\n\+\+\+ b\/version\.h\n@@ .* @@\n(?:[-\+ ].*\n|\n)+/, '')
-
-      message = "#{(patch[/^Subject: (.*)\n---\n /m, 1] || "Message not found for revision: #{git_rev}\n")}"
-      message.gsub!(/\G(.*)\n( .*)/, "\\1\\2")
-      message = "\n\n#{message}"
+    # Merge revision from Git patch
+    git_uri = "https://git.ruby-lang.org/ruby.git/patch/?id=#{git_rev}"
+    resp = Net::HTTP.get_response(URI(git_uri))
+    if resp.code != '200'
+      abort "'#{git_uri}' returned status '#{resp.code}':\n#{resp.body}"
+    end
+    patch = resp.body.sub(/^diff --git a\/version\.h b\/version\.h\nindex .*\n--- a\/version\.h\n\+\+\+ b\/version\.h\n@@ .* @@\n(?:[-\+ ].*\n|\n)+/, '')
 
-      puts '+ git apply'
-      IO.popen(['git', 'apply', '--3way'], 'wb') { |f| f.write(patch) }
-    else
-      default_merge_branch = (%r{^URL: .*/branches/ruby_1_8_} =~ `svn info` ? 'branches/ruby_1_8' : 'trunk')
-      svn_src = "#{Merger::REPOS}#{ARGV[1] || default_merge_branch}"
-      message = IO.popen(['svn', 'log', '-c', svn_rev, svn_src], &:read)
+    message = "#{(patch[/^Subject: (.*)\n---\n /m, 1] || "Message not found for revision: #{git_rev}\n")}"
+    message.gsub!(/\G(.*)\n( .*)/, "\\1\\2")
+    message = "\n\n#{message}"
 
-      cmd = ['svn', 'merge', '--accept=postpone', '-c', svn_rev, svn_src]
-      puts "+ #{cmd.join(' ')}"
-      system(*cmd)
-    end
+    puts '+ git apply'
+    IO.popen(['git', 'apply', '--3way'], 'wb') { |f| f.write(patch) }
 
     commit_message << message.sub(/\A-+\nr.*/, '').sub(/\n-+\n\z/, '').gsub(/^./, "\t\\&")
   end

From d1265d6172f2772bd4b37cf72689de28edce8a96 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 14:05:50 -0700
Subject: [PATCH 236/242] merger.rb: Improve the help message

It wasn't clear whether the backport command takes a commit hash or a
ticket number.
---
 tool/merger.rb | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tool/merger.rb b/tool/merger.rb
index 9aac5e85695801..39459003a52b17 100755
--- a/tool/merger.rb
+++ b/tool/merger.rb
@@ -18,10 +18,10 @@ class << Merger = Object.new
   def help
     puts <<-HELP
 \e[1msimple backport\e[0m
-  ruby #$0 1234
+  ruby #$0 1234abc
 
 \e[1mbackport from other branch\e[0m
-  ruby #$0 17502 mvm
+  ruby #$0 1234abc mvm
 
 \e[1mrevision increment\e[0m
   ruby #$0 revisionup
@@ -30,16 +30,16 @@ def help
   ruby #$0 teenyup
 
 \e[1mtagging major release\e[0m
-  ruby #$0 tag 2.2.0
+  ruby #$0 tag 3.2.0
 
-\e[1mtagging patch release\e[0m (about 2.1.0 or later, it means X.Y.Z (Z > 0) release)
+\e[1mtagging patch release\e[0m (for 2.1.0 or later, it means X.Y.Z (Z > 0) release)
   ruby #$0 tag
 
 \e[1mtagging preview/RC\e[0m
-  ruby #$0 tag 2.2.0-preview1
+  ruby #$0 tag 3.2.0-preview1
 
 \e[1mremove tag\e[0m
-  ruby #$0 removetag 2.2.9
+  ruby #$0 removetag 3.2.9
 
 \e[33;1m* all operations shall be applied to the working directory.\e[0m
     HELP

From b0ebad51e504a1182f29026be755b2e7a8756080 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 14:28:49 -0700
Subject: [PATCH 237/242] merger.rb: Use commit: prefix in more places

---
 tool/redmine-backporter.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index eb917a9d81e4bf..596ae464b0382f 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -355,7 +355,7 @@ class << @changesets
     if log && rev
       str = log[/merge revision\(s\) ([^:]+)(?=:)/]
       if str
-        str.insert(5, "d")
+        str.sub!(/merge revision\(s\) /, "merged revision(s) commit:")
         str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev} #{str}."
       else
         str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev}."

From 24c56ed516893fe33e34f85f8807c230db20b65b Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 15:42:47 -0700
Subject: [PATCH 238/242] merger.rb: Drop an obsoleted command from help

It was needed only for SVN, and we dropped SVN support.
---
 tool/merger.rb | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tool/merger.rb b/tool/merger.rb
index 39459003a52b17..48a021fcae604b 100755
--- a/tool/merger.rb
+++ b/tool/merger.rb
@@ -20,9 +20,6 @@ def help
 \e[1msimple backport\e[0m
   ruby #$0 1234abc
 
-\e[1mbackport from other branch\e[0m
-  ruby #$0 1234abc mvm
-
 \e[1mrevision increment\e[0m
   ruby #$0 revisionup
 

From 2eded6cc5d08510e9bff6242bfc86d10b68a3b82 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 16:28:00 -0700
Subject: [PATCH 239/242] merger.rb: Auto-detect tickets when --ticket is not
 given

---
 tool/merger.rb | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/tool/merger.rb b/tool/merger.rb
index 48a021fcae604b..7ab163eb37ba78 100755
--- a/tool/merger.rb
+++ b/tool/merger.rb
@@ -223,10 +223,11 @@ def execute(*cmd, interactive: false)
 
   case ARGV[0]
   when /--ticket=(.*)/
-    tickets = $1.split(/,/).map{|num| " [Backport ##{num}]"}.join
+    tickets = $1.split(/,/)
     ARGV.shift
   else
-    tickets = ''
+    tickets = []
+    detect_ticket = true
   end
 
   revstr = ARGV[0].gsub(%r!https://github\.com/ruby/ruby/commit/|https://bugs\.ruby-lang\.org/projects/ruby-master/repository/git/revisions/!, '')
@@ -255,6 +256,10 @@ def execute(*cmd, interactive: false)
     end
     patch = resp.body.sub(/^diff --git a\/version\.h b\/version\.h\nindex .*\n--- a\/version\.h\n\+\+\+ b\/version\.h\n@@ .* @@\n(?:[-\+ ].*\n|\n)+/, '')
 
+    if detect_ticket
+      tickets += patch.scan(/\[(?:Bug|Feature|Misc) #(\d+)\]/i).map(&:first)
+    end
+
     message = "#{(patch[/^Subject: (.*)\n---\n /m, 1] || "Message not found for revision: #{git_rev}\n")}"
     message.gsub!(/\G(.*)\n( .*)/, "\\1\\2")
     message = "\n\n#{message}"
@@ -271,7 +276,7 @@ def execute(*cmd, interactive: false)
 
   Merger.version_up
   f = Tempfile.new 'merger.rb'
-  f.printf "merge revision(s) %s:%s", revstr, tickets
+  f.printf "merge revision(s) %s:%s", revstr, tickets.map{|num| " [Backport ##{num}]"}.join
   f.write commit_message
   f.flush
   f.close

From d0cde43a3371369275495f24446880cf59288e79 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 17:00:12 -0700
Subject: [PATCH 240/242] redmine-backporter.rb: Remove an unneeded space

from #backport_command_string

I don't want to leave unneeded spaces in the command history by
copy-pasting the entire line.
---
 tool/redmine-backporter.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index 596ae464b0382f..d79281fc45b56e 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -194,7 +194,7 @@ def backport_command_string
     end
     @changesets.define_singleton_method(:validated){true}
   end
-  " #{merger_path} --ticket=#{@issue} #{@changesets.sort.join(',')}"
+  "#{merger_path} --ticket=#{@issue} #{@changesets.sort.join(',')}"
 end
 
 def status_char(obj)

From 7e95efdafa32bbff4b54e563a7c47fcbc76d7111 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 17:17:03 -0700
Subject: [PATCH 241/242] redmine-backporter.rb: Prepend commit: to every
 revision

---
 tool/redmine-backporter.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tool/redmine-backporter.rb b/tool/redmine-backporter.rb
index d79281fc45b56e..bbd85d0e19a3a1 100755
--- a/tool/redmine-backporter.rb
+++ b/tool/redmine-backporter.rb
@@ -355,7 +355,8 @@ class << @changesets
     if log && rev
       str = log[/merge revision\(s\) ([^:]+)(?=:)/]
       if str
-        str.sub!(/merge revision\(s\) /, "merged revision(s) commit:")
+        str.sub!(/\Amerge/, 'merged')
+        str.gsub!(/\h{40}/, 'commit:\0')
         str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev} #{str}."
       else
         str = "ruby_#{TARGET_VERSION.tr('.','_')} commit:#{rev}."

From d9d7ae7830370ff88b69aded2032b17c412fdaf3 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Tue, 28 May 2024 17:45:21 -0700
Subject: [PATCH 242/242] merger.rb: Don't ask "conflicts resolved?" if not
 needed

---
 tool/merger.rb | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/tool/merger.rb b/tool/merger.rb
index 7ab163eb37ba78..a690b47da336e5 100755
--- a/tool/merger.rb
+++ b/tool/merger.rb
@@ -163,6 +163,17 @@ def commit(file)
     execute('git', 'add', '.') && execute('git', 'commit', '-F', file)
   end
 
+  def has_conflicts?
+    changes = IO.popen(%w[git status --porcelain -z]) { |io| io.readlines("\0", chomp: true) }
+    # Discover unmerged files
+    # AU: unmerged, added by us
+    # DU: unmerged, deleted by us
+    # UU: unmerged, both modified
+    # AA: unmerged, both added
+    conflict = changes.grep(/\A(?:.U|AA) /) {$'}
+    !conflict.empty?
+  end
+
   private
 
   # Prints the version of Ruby found in version.h
@@ -281,15 +292,17 @@ def execute(*cmd, interactive: false)
   f.flush
   f.close
 
-  Merger.interactive('conflicts resolved?', f.path) do
-    IO.popen(ENV['PAGER'] || ['less', '-R'], 'w') do |g|
-      g << Merger.stat
-      g << "\n\n"
-      f.open
-      g << f.read
-      f.close
-      g << "\n\n"
-      g << Merger.diff
+  if Merger.has_conflicts?
+    Merger.interactive('conflicts resolved?', f.path) do
+      IO.popen(ENV['PAGER'] || ['less', '-R'], 'w') do |g|
+        g << Merger.stat
+        g << "\n\n"
+        f.open
+        g << f.read
+        f.close
+        g << "\n\n"
+        g << Merger.diff
+      end
     end
   end