15 files changed, 417 insertions, 490 deletions
diff --git a/spec/ruby/core/module/ancestors_spec.rb b/spec/ruby/core/module/ancestors_spec.rb
index 43ebdb864f..90c26941d1 100644
--- a/spec/ruby/core/module/ancestors_spec.rb
+++ b/spec/ruby/core/module/ancestors_spec.rb
@@ -7,10 +7,17 @@ describe "Module#ancestors" do
     ModuleSpecs.ancestors.should == [ModuleSpecs]
     ModuleSpecs::Basic.ancestors.should == [ModuleSpecs::Basic]
     ModuleSpecs::Super.ancestors.should == [ModuleSpecs::Super, ModuleSpecs::Basic]
-    ModuleSpecs.without_test_modules(ModuleSpecs::Parent.ancestors).should ==
-      [ModuleSpecs::Parent, Object, Kernel, BasicObject]
-    ModuleSpecs.without_test_modules(ModuleSpecs::Child.ancestors).should ==
-      [ModuleSpecs::Child, ModuleSpecs::Super, ModuleSpecs::Basic, ModuleSpecs::Parent, Object, Kernel, BasicObject]
+    if defined?(Ruby::Box) && Ruby::Box.enabled?
+      ModuleSpecs.without_test_modules(ModuleSpecs::Parent.ancestors).should ==
+        [ModuleSpecs::Parent, Object, Ruby::Box::Loader, Kernel, BasicObject]
+      ModuleSpecs.without_test_modules(ModuleSpecs::Child.ancestors).should ==
+        [ModuleSpecs::Child, ModuleSpecs::Super, ModuleSpecs::Basic, ModuleSpecs::Parent, Object, Ruby::Box::Loader, Kernel, BasicObject]
+    else
+      ModuleSpecs.without_test_modules(ModuleSpecs::Parent.ancestors).should ==
+        [ModuleSpecs::Parent, Object, Kernel, BasicObject]
+      ModuleSpecs.without_test_modules(ModuleSpecs::Child.ancestors).should ==
+        [ModuleSpecs::Child, ModuleSpecs::Super, ModuleSpecs::Basic, ModuleSpecs::Parent, Object, Kernel, BasicObject]
+    end
   end
 
   it "returns only modules and classes" do
diff --git a/spec/ruby/core/module/autoload_spec.rb b/spec/ruby/core/module/autoload_spec.rb
index 3cdc48f9ba..625d945686 100644
--- a/spec/ruby/core/module/autoload_spec.rb
+++ b/spec/ruby/core/module/autoload_spec.rb
@@ -603,32 +603,30 @@ describe "Module#autoload" do
       end
     end
 
-    ruby_version_is "3.2" do
-      it "warns once in verbose mode if the constant was defined in a parent scope" do
-        ScratchPad.record -> {
-          ModuleSpecs::DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
-        }
+    it "warns once in verbose mode if the constant was defined in a parent scope" do
+      ScratchPad.record -> {
+        ModuleSpecs::DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
+      }
 
-        module ModuleSpecs
-          module Autoload
-            autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == fixture(__FILE__, "autoload_callback.rb")
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == true
-
-            -> {
-              DeclaredInCurrentDefinedInParent
-            }.should complain(
-              /Expected .*autoload_callback.rb to define ModuleSpecs::Autoload::DeclaredInCurrentDefinedInParent but it didn't/,
-              verbose: true,
-            )
-
-            -> {
-              DeclaredInCurrentDefinedInParent
-            }.should_not complain(/.*/, verbose: true)
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == false
-            ModuleSpecs.const_defined?(:DeclaredInCurrentDefinedInParent).should == true
-          end
+      module ModuleSpecs
+        module Autoload
+          autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
+          self.autoload?(:DeclaredInCurrentDefinedInParent).should == fixture(__FILE__, "autoload_callback.rb")
+          const_defined?(:DeclaredInCurrentDefinedInParent).should == true
+
+          -> {
+            DeclaredInCurrentDefinedInParent
+          }.should complain(
+            /Expected .*autoload_callback.rb to define ModuleSpecs::Autoload::DeclaredInCurrentDefinedInParent but it didn't/,
+            verbose: true,
+          )
+
+          -> {
+            DeclaredInCurrentDefinedInParent
+          }.should_not complain(/.*/, verbose: true)
+          self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
+          const_defined?(:DeclaredInCurrentDefinedInParent).should == false
+          ModuleSpecs.const_defined?(:DeclaredInCurrentDefinedInParent).should == true
         end
       end
     end
@@ -720,6 +718,21 @@ describe "Module#autoload" do
     end
   end
 
+  it "should trigger the autoload when using `private_constant`" do
+    @remove << :DynClass
+    module ModuleSpecs::Autoload
+      autoload :DynClass, fixture(__FILE__, "autoload_c.rb")
+      private_constant :DynClass
+
+      ScratchPad.recorded.should be_nil
+
+      DynClass::C.new.loaded.should == :dynclass_c
+      ScratchPad.recorded.should == :loaded
+    end
+
+    -> { ModuleSpecs::Autoload::DynClass }.should raise_error(NameError, /private constant/)
+  end
+
   # [ruby-core:19127] [ruby-core:29941]
   it "does NOT raise a NameError when the autoload file did not define the constant and a module is opened with the same name" do
     module ModuleSpecs::Autoload
diff --git a/spec/ruby/core/module/const_added_spec.rb b/spec/ruby/core/module/const_added_spec.rb
index 1b3dad514b..90cd36551a 100644
--- a/spec/ruby/core/module/const_added_spec.rb
+++ b/spec/ruby/core/module/const_added_spec.rb
@@ -3,221 +3,236 @@ require_relative 'fixtures/classes'
 require_relative 'fixtures/const_added'
 
 describe "Module#const_added" do
-  ruby_version_is "3.2" do
-    it "is a private instance method" do
-      Module.should have_private_instance_method(:const_added)
+  it "is a private instance method" do
+    Module.should have_private_instance_method(:const_added)
+  end
+
+  it "returns nil in the default implementation" do
+    Module.new do
+      const_added(:TEST).should == nil
     end
+  end
+
+  it "for a class defined with the `class` keyword, const_added runs before inherited" do
+    ScratchPad.record []
 
-    it "returns nil in the default implementation" do
-      Module.new do
-        const_added(:TEST).should == nil
+    mod = Module.new do
+      def self.const_added(_)
+        ScratchPad << :const_added
       end
     end
 
-    it "is called when a new constant is assigned on self" do
-      ScratchPad.record []
-
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    parent = Class.new do
+      def self.inherited(_)
+        ScratchPad << :inherited
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 1
-      RUBY
+    class mod::C < parent; end
 
-      ScratchPad.recorded.should == [:TEST]
-    end
+    ScratchPad.recorded.should == [:const_added, :inherited]
+  end
 
-    it "is called when a new constant is assigned on self through const_set" do
-      ScratchPad.record []
+  it "the superclass of a class assigned to a constant is set before const_added is called" do
+    ScratchPad.record []
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    parent = Class.new do
+      def self.const_added(name)
+        ScratchPad << name
+        ScratchPad << const_get(name).superclass
       end
+    end
 
-      mod.const_set(:TEST, 1)
+    class parent::C < parent; end
 
-      ScratchPad.recorded.should == [:TEST]
-    end
+    ScratchPad.recorded.should == [:C, parent]
+  end
 
-    it "is called when a new module is defined under self" do
-      ScratchPad.record []
+  it "is called when a new constant is assigned on self" do
+    ScratchPad.record []
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        module SubModule
-        end
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 1
+    RUBY
 
-        module SubModule
-        end
-      RUBY
+    ScratchPad.recorded.should == [:TEST]
+  end
+
+  it "is called when a new constant is assigned on self through const_set" do
+    ScratchPad.record []
 
-      ScratchPad.recorded.should == [:SubModule]
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
     end
 
-    it "is called when a new module is defined under a named module (assigned to a constant)" do
-      ScratchPad.record []
+    mod.const_set(:TEST, 1)
 
-      ModuleSpecs::ConstAddedSpecs::NamedModule = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    ScratchPad.recorded.should == [:TEST]
+  end
 
-        module self::A
-          def self.const_added(name)
-            ScratchPad << name
-          end
+  it "is called when a new module is defined under self" do
+    ScratchPad.record []
 
-          module self::B
-          end
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
-
-      ScratchPad.recorded.should == [:A, :B]
     end
 
-    it "is called when a new class is defined under self" do
-      ScratchPad.record []
-
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      module SubModule
       end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        class SubClass
-        end
+      module SubModule
+      end
+    RUBY
 
-        class SubClass
-        end
-      RUBY
+    ScratchPad.recorded.should == [:SubModule]
+  end
 
-      ScratchPad.recorded.should == [:SubClass]
-    end
+  it "is called when a new module is defined under a named module (assigned to a constant)" do
+    ScratchPad.record []
 
-    it "is called when a new class is defined under a named module (assigned to a constant)" do
-      ScratchPad.record []
+    ModuleSpecs::ConstAddedSpecs::NamedModule = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
 
-      ModuleSpecs::ConstAddedSpecs::NamedModuleB = Module.new do
+      module self::A
         def self.const_added(name)
           ScratchPad << name
         end
 
-        class self::A
-          def self.const_added(name)
-            ScratchPad << name
-          end
-
-          class self::B
-          end
+        module self::B
         end
       end
-
-      ScratchPad.recorded.should == [:A, :B]
     end
 
-    it "is called when an autoload is defined" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [:A, :B]
+    ModuleSpecs::ConstAddedSpecs.send :remove_const, :NamedModule
+  end
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
-      end
+  it "is called when a new class is defined under self" do
+    ScratchPad.record []
 
-      mod.autoload :Autoload, "foo"
-      ScratchPad.recorded.should == [:Autoload]
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
     end
 
-    it "is called with a precise caller location with the line of definition" do
-      ScratchPad.record []
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      class SubClass
+      end
 
-      mod = Module.new do
-        def self.const_added(name)
-          location = caller_locations(1, 1)[0]
-          ScratchPad << location.lineno
-        end
+      class SubClass
       end
+    RUBY
 
-      line = __LINE__
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 1
+    ScratchPad.recorded.should == [:SubClass]
+  end
 
-        module SubModule
-        end
+  it "is called when a new class is defined under a named module (assigned to a constant)" do
+    ScratchPad.record []
 
-        class SubClass
-        end
-      RUBY
+    ModuleSpecs::ConstAddedSpecs::NamedModuleB = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
 
-      mod.const_set(:CONST_SET, 1)
+      class self::A
+        def self.const_added(name)
+          ScratchPad << name
+        end
 
-      ScratchPad.recorded.should == [line + 2, line + 4, line + 7, line + 11]
+        class self::B
+        end
+      end
     end
 
-    it "is called when the constant is already assigned a value" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [:A, :B]
+    ModuleSpecs::ConstAddedSpecs.send :remove_const, :NamedModuleB
+  end
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad.record const_get(name)
-        end
+  it "is called when an autoload is defined" do
+    ScratchPad.record []
+
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 123
-      RUBY
+    mod.autoload :Autoload, "foo"
+    ScratchPad.recorded.should == [:Autoload]
+  end
+
+  it "is called with a precise caller location with the line of definition" do
+    ScratchPad.record []
 
-      ScratchPad.recorded.should == 123
+    mod = Module.new do
+      def self.const_added(name)
+        location = caller_locations(1, 1)[0]
+        ScratchPad << location.lineno
+      end
     end
 
-    it "records re-definition of existing constants" do
-      ScratchPad.record []
+    line = __LINE__
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 1
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << const_get(name)
-        end
+      module SubModule
       end
 
-      -> {
-        mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          TEST = 123
-          TEST = 456
-        RUBY
-      }.should complain(/warning: already initialized constant .+::TEST/)
+      class SubClass
+      end
+    RUBY
 
-      ScratchPad.recorded.should == [123, 456]
-    end
+    mod.const_set(:CONST_SET, 1)
 
-    it "for a class defined with the `class` keyword, const_added runs before inherited" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [line + 2, line + 4, line + 7, line + 11]
+  end
 
-      mod = Module.new do
-        def self.const_added(_)
-          ScratchPad << :const_added
-        end
-      end
+  it "is called when the constant is already assigned a value" do
+    ScratchPad.record []
 
-      parent = Class.new do
-        def self.inherited(_)
-          ScratchPad << :inherited
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad.record const_get(name)
       end
+    end
+
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 123
+    RUBY
+
+    ScratchPad.recorded.should == 123
+  end
 
-      class mod::C < parent; end
+  it "records re-definition of existing constants" do
+    ScratchPad.record []
 
-      ScratchPad.recorded.should == [:const_added, :inherited]
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << const_get(name)
+      end
     end
+
+    -> {
+      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        TEST = 123
+        TEST = 456
+      RUBY
+    }.should complain(/warning: already initialized constant .+::TEST/)
+
+    ScratchPad.recorded.should == [123, 456]
   end
 end
diff --git a/spec/ruby/core/module/const_source_location_spec.rb b/spec/ruby/core/module/const_source_location_spec.rb
index 06b3b215c2..96649ea10b 100644
--- a/spec/ruby/core/module/const_source_location_spec.rb
+++ b/spec/ruby/core/module/const_source_location_spec.rb
@@ -245,6 +245,14 @@ describe "Module#const_source_location" do
       @line = __LINE__ - 1
     end
 
+    before :each do
+      @loaded_features = $".dup
+    end
+
+    after :each do
+      $".replace @loaded_features
+    end
+
     it 'returns the autoload location while not resolved' do
       ConstantSpecs.const_source_location('CSL_CONST1').should == [__FILE__, @line]
     end
@@ -265,6 +273,8 @@ describe "Module#const_source_location" do
         ConstantSpecs.const_source_location(:ConstSource).should == autoload_location
         ConstantSpecs::ConstSource::LOCATION.should == ConstantSpecs.const_source_location(:ConstSource)
         ConstantSpecs::BEFORE_DEFINE_LOCATION.should == autoload_location
+        ConstantSpecs.send :remove_const, :ConstSource
+        ConstantSpecs.send :remove_const, :BEFORE_DEFINE_LOCATION
       end
     end
   end
diff --git a/spec/ruby/core/module/fixtures/classes.rb b/spec/ruby/core/module/fixtures/classes.rb
index a434e7b0b8..964f64c593 100644
--- a/spec/ruby/core/module/fixtures/classes.rb
+++ b/spec/ruby/core/module/fixtures/classes.rb
@@ -1,6 +1,6 @@
 module ModuleSpecs
   def self.without_test_modules(modules)
-    ignore = %w[MSpecRSpecAdapter PP::ObjectMixin ModuleSpecs::IncludedInObject MainSpecs::Module ConstantSpecs::ModuleA]
+    ignore = %w[MSpecRSpecAdapter PP::ObjectMixin MainSpecs::Module ConstantSpecs::ModuleA]
     modules.reject { |k| ignore.include?(k.name) }
   end
 
diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb
index a1bfd3a6f5..210918b2e7 100644
--- a/spec/ruby/core/module/include_spec.rb
+++ b/spec/ruby/core/module/include_spec.rb
@@ -51,32 +51,16 @@ describe "Module#include" do
     ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises ArgumentError when the argument is a refinement" do
-      refinement = nil
+  it "raises a TypeError when the argument is a refinement" do
+    refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
+    Module.new do
+      refine String do
+        refinement = self
       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
+    -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(TypeError, "Cannot include refinement")
   end
 
   it "imports constants to modules and classes" do
diff --git a/spec/ruby/core/module/instance_method_spec.rb b/spec/ruby/core/module/instance_method_spec.rb
index 8d006e647e..182cdf5c54 100644
--- a/spec/ruby/core/module/instance_method_spec.rb
+++ b/spec/ruby/core/module/instance_method_spec.rb
@@ -48,11 +48,6 @@ describe "Module#instance_method" do
 
     @mod_um.inspect.should =~ /\bbar\b/
     @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethMod\b/
-
-    ruby_version_is ""..."3.2" do
-      @child_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/
-      @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/
-    end
   end
 
   it "raises a TypeError if the given name is not a String/Symbol" do
diff --git a/spec/ruby/core/module/name_spec.rb b/spec/ruby/core/module/name_spec.rb
index b5c1f771f8..d3318e1645 100644
--- a/spec/ruby/core/module/name_spec.rb
+++ b/spec/ruby/core/module/name_spec.rb
@@ -153,45 +153,44 @@ describe "Module#name" do
     ModuleSpecs::Anonymous.send(:remove_const, :StoredInMultiplePlaces)
   end
 
-  ruby_version_is "3.2" do
-    it "is set in #const_added callback when a module defined in the top-level scope" do
-      ruby_exe(<<~RUBY, args: "2>&1").chomp.should == "TEST1\nTEST2"
-        class Module
-          def const_added(name)
-            puts const_get(name).name
-          end
+  it "is set in #const_added callback when a module defined in the top-level scope" do
+    ruby_exe(<<~RUBY, args: "2>&1").chomp.should == "TEST1\nTEST2"
+      class Module
+        def const_added(name)
+          puts const_get(name).name
         end
+      end
 
-        # module with name
-        module TEST1
-        end
+      # module with name
+      module TEST1
+      end
 
-        # anonymous module
-        TEST2 = Module.new
-      RUBY
-    end
+      # anonymous module
+      TEST2 = Module.new
+    RUBY
+  end
 
-    it "is set in #const_added callback for a nested module when an outer module defined in the top-level scope" do
-      ScratchPad.record []
+  it "is set in #const_added callback for a nested module when an outer module defined in the top-level scope" do
+    ScratchPad.record []
 
-      ModuleSpecs::NameSpecs::NamedModule = Module.new do
+    ModuleSpecs::NameSpecs::NamedModule = Module.new do
+      def self.const_added(name)
+        ScratchPad << const_get(name).name
+      end
+
+      module self::A
         def self.const_added(name)
           ScratchPad << const_get(name).name
         end
 
-        module self::A
-          def self.const_added(name)
-            ScratchPad << const_get(name).name
-          end
-
-          module self::B
-          end
+        module self::B
         end
       end
-
-      ScratchPad.recorded.should.one?(/#<Module.+>::A$/)
-      ScratchPad.recorded.should.one?(/#<Module.+>::A::B$/)
     end
+
+    ScratchPad.recorded.should.one?(/#<Module.+>::A$/)
+    ScratchPad.recorded.should.one?(/#<Module.+>::A::B$/)
+    ModuleSpecs::NameSpecs.send :remove_const, :NamedModule
   end
 
   it "returns a frozen String" do
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
index 9508fbf182..71e82c513e 100644
--- a/spec/ruby/core/module/prepend_spec.rb
+++ b/spec/ruby/core/module/prepend_spec.rb
@@ -455,32 +455,16 @@ describe "Module#prepend" do
     ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises ArgumentError when the argument is a refinement" do
-      refinement = nil
+  it "raises a TypeError when the argument is a refinement" do
+    refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
+    Module.new do
+      refine String do
+        refinement = self
       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
+    -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(TypeError, "Cannot prepend refinement")
   end
 
   it "imports constants" do
diff --git a/spec/ruby/core/module/refine_spec.rb b/spec/ruby/core/module/refine_spec.rb
index 7a5d607c4f..d219b98825 100644
--- a/spec/ruby/core/module/refine_spec.rb
+++ b/spec/ruby/core/module/refine_spec.rb
@@ -243,32 +243,6 @@ describe "Module#refine" do
       result.should == "foo from singleton class"
     end
 
-    ruby_version_is ""..."3.2" do
-      it "looks in the included modules for builtin methods" do
-        result = ruby_exe(<<-RUBY)
-          a = Module.new do
-            def /(other) quo(other) end
-          end
-
-          refinement = Module.new do
-            refine Integer do
-              include a
-            end
-          end
-
-          result = nil
-          Module.new do
-            using refinement
-            result = 1 / 2
-          end
-
-          print result.class
-        RUBY
-
-        result.should == 'Rational'
-      end
-    end
-
     it "looks in later included modules of the refined module first" do
       a = Module.new do
         def foo
diff --git a/spec/ruby/core/module/refinements_spec.rb b/spec/ruby/core/module/refinements_spec.rb
index 5648fcbd6f..05658a8b0e 100644
--- a/spec/ruby/core/module/refinements_spec.rb
+++ b/spec/ruby/core/module/refinements_spec.rb
@@ -1,45 +1,43 @@
 require_relative '../../spec_helper'
 
 describe "Module#refinements" do
-  ruby_version_is "3.2" do
-    it "returns refinements defined in a module" do
-      ScratchPad.record []
-
-      m = Module.new do
-        refine String do
-          ScratchPad << self
-        end
-
-        refine Array do
-          ScratchPad << self
-        end
+  it "returns refinements defined in a module" do
+    ScratchPad.record []
+
+    m = Module.new do
+      refine String do
+        ScratchPad << self
       end
 
-      m.refinements.sort_by(&:object_id).should == ScratchPad.recorded.sort_by(&:object_id)
+      refine Array do
+        ScratchPad << self
+      end
     end
 
-    it "does not return refinements defined in the included module" do
-      ScratchPad.record []
+    m.refinements.sort_by(&:object_id).should == ScratchPad.recorded.sort_by(&:object_id)
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          nil
-        end
+  it "does not return refinements defined in the included module" do
+    ScratchPad.record []
+
+    m1 = Module.new do
+      refine Integer do
+        nil
       end
+    end
 
-      m2 = Module.new do
-        include m1
+    m2 = Module.new do
+      include m1
 
-        refine String do
-          ScratchPad << self
-        end
+      refine String do
+        ScratchPad << self
       end
-
-      m2.refinements.should == ScratchPad.recorded
     end
 
-    it "returns an empty array if no refinements defined in a module" do
-      Module.new.refinements.should == []
-    end
+    m2.refinements.should == ScratchPad.recorded
+  end
+
+  it "returns an empty array if no refinements defined in a module" do
+    Module.new.refinements.should == []
   end
 end
diff --git a/spec/ruby/core/module/ruby2_keywords_spec.rb b/spec/ruby/core/module/ruby2_keywords_spec.rb
index aca419f522..652f9f7083 100644
--- a/spec/ruby/core/module/ruby2_keywords_spec.rb
+++ b/spec/ruby/core/module/ruby2_keywords_spec.rb
@@ -76,122 +76,60 @@ describe "Module#ruby2_keywords" do
     Hash.ruby2_keywords_hash?(marked).should == true
   end
 
-  ruby_version_is "3.2" do
-    it "makes a copy and unmark the Hash when calling a method taking (*args)" do
-      obj = Object.new
-      obj.singleton_class.class_exec do
-        def splat(*args)
-          args.last
-        end
-
-        def splat1(arg, *args)
-          args.last
-        end
+  it "makes a copy and unmark the Hash when calling a method taking (*args)" do
+    obj = Object.new
+    obj.singleton_class.class_exec do
+      def splat(*args)
+        args.last
+      end
 
-        def proc_call(*args)
-          -> *a { a.last }.call(*args)
-        end
+      def splat1(arg, *args)
+        args.last
       end
 
-      h = { a: 1 }
-      args = mark(**h)
-      marked = args.last
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      after_usage = obj.splat(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(1, **h)
-      marked = args.last
-      after_usage = obj.splat1(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.proc_call(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.send(:splat, *args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
+      def proc_call(*args)
+        -> *a { a.last }.call(*args)
+      end
     end
-  end
 
-  ruby_version_is ""..."3.2" do
-    # https://bugs.ruby-lang.org/issues/18625
-    it "does NOT copy the Hash when calling a method taking (*args)" do
-      obj = Object.new
-      obj.singleton_class.class_exec do
-        def splat(*args)
-          args.last
-        end
+    h = { a: 1 }
+    args = mark(**h)
+    marked = args.last
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-        def splat1(arg, *args)
-          args.last
-        end
+    after_usage = obj.splat(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-        def proc_call(*args)
-          -> *a { a.last }.call(*args)
-        end
-      end
+    args = mark(1, **h)
+    marked = args.last
+    after_usage = obj.splat1(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-      h = { a: 1 }
-      args = mark(**h)
-      marked = args.last
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      after_usage = obj.splat(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(1, **h)
-      marked = args.last
-      after_usage = obj.splat1(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.proc_call(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.send(:splat, *args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      send_copies = RUBY_ENGINE == "ruby" # inconsistent with Proc#call above for CRuby
-      after_usage.equal?(marked).should == !send_copies
-      Hash.ruby2_keywords_hash?(after_usage).should == !send_copies
-      Hash.ruby2_keywords_hash?(marked).should == true
-    end
+    args = mark(**h)
+    marked = args.last
+    after_usage = obj.proc_call(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
+
+    args = mark(**h)
+    marked = args.last
+    after_usage = obj.send(:splat, *args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
   end
 
   it "applies to the underlying method and applies across aliasing" do
@@ -275,7 +213,7 @@ describe "Module#ruby2_keywords" do
 
   it "prints warning when a method accepts keywords" do
     obj = Object.new
-    def obj.foo(a:, b:) end
+    def obj.foo(*a, b:) end
 
     -> {
       obj.singleton_class.class_exec do
@@ -286,7 +224,7 @@ describe "Module#ruby2_keywords" do
 
   it "prints warning when a method accepts keyword splat" do
     obj = Object.new
-    def obj.foo(**a) end
+    def obj.foo(*a, **b) end
 
     -> {
       obj.singleton_class.class_exec do
@@ -294,4 +232,17 @@ describe "Module#ruby2_keywords" do
       end
     }.should complain(/Skipping set of ruby2_keywords flag for/)
   end
+
+  ruby_version_is "4.0" do
+    it "prints warning when a method accepts post arguments" do
+      obj = Object.new
+      def obj.foo(*a, b) end
+
+      -> {
+        obj.singleton_class.class_exec do
+          ruby2_keywords :foo
+        end
+      }.should complain(/Skipping set of ruby2_keywords flag for/)
+    end
+  end
 end
diff --git a/spec/ruby/core/module/set_temporary_name_spec.rb b/spec/ruby/core/module/set_temporary_name_spec.rb
index 12c1c214dd..46605ed675 100644
--- a/spec/ruby/core/module/set_temporary_name_spec.rb
+++ b/spec/ruby/core/module/set_temporary_name_spec.rb
@@ -86,6 +86,7 @@ ruby_version_is "3.3" do
 
       ModuleSpecs::SetTemporaryNameSpec::M = m
       m::N.name.should == "ModuleSpecs::SetTemporaryNameSpec::M::N"
+      ModuleSpecs::SetTemporaryNameSpec.send :remove_const, :M
     end
 
     it "can update the name when assigned to a constant" do
@@ -108,7 +109,7 @@ ruby_version_is "3.3" do
       m.name.should == "fake_name_2"
     end
 
-    ruby_bug "#21094", ""..."3.5" do
+    ruby_bug "#21094", ""..."4.0" do
       it "also updates a name of a nested module" do
         m = Module.new
         m::N = Module.new
diff --git a/spec/ruby/core/module/undefined_instance_methods_spec.rb b/spec/ruby/core/module/undefined_instance_methods_spec.rb
index 3be860d053..d33ee93fc1 100644
--- a/spec/ruby/core/module/undefined_instance_methods_spec.rb
+++ b/spec/ruby/core/module/undefined_instance_methods_spec.rb
@@ -2,25 +2,23 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Module#undefined_instance_methods" do
-  ruby_version_is "3.2" do
-    it "returns methods undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Parent.undefined_instance_methods
-      methods.should == [:undefed_method]
-    end
+  it "returns methods undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Parent.undefined_instance_methods
+    methods.should == [:undefed_method]
+  end
 
-    it "returns inherited methods undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Child.undefined_instance_methods
-      methods.should include(:parent_method, :another_parent_method)
-    end
+  it "returns inherited methods undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Child.undefined_instance_methods
+    methods.should include(:parent_method, :another_parent_method)
+  end
 
-    it "returns methods from an included module that are undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
-      methods.should include(:super_included_method)
-    end
+  it "returns methods from an included module that are undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
+    methods.should include(:super_included_method)
+  end
 
-    it "does not returns ancestors undefined methods" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
-      methods.should_not include(:parent_method, :another_parent_method)
-    end
+  it "does not returns ancestors undefined methods" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
+    methods.should_not include(:parent_method, :another_parent_method)
   end
 end
diff --git a/spec/ruby/core/module/used_refinements_spec.rb b/spec/ruby/core/module/used_refinements_spec.rb
index c16cab0e3c..40dd4a444e 100644
--- a/spec/ruby/core/module/used_refinements_spec.rb
+++ b/spec/ruby/core/module/used_refinements_spec.rb
@@ -1,87 +1,85 @@
 require_relative '../../spec_helper'
 
 describe "Module.used_refinements" do
-  ruby_version_is "3.2" do
-    it "returns list of all refinements imported in the current scope" do
-      refinement_int = nil
-      refinement_str = nil
-      ScratchPad.record []
-
-      m1 = Module.new do
-        refine Integer do
-          refinement_int = self
-        end
+  it "returns list of all refinements imported in the current scope" do
+    refinement_int = nil
+    refinement_str = nil
+    ScratchPad.record []
+
+    m1 = Module.new do
+      refine Integer do
+        refinement_int = self
       end
+    end
 
-      m2 = Module.new do
-        refine String do
-          refinement_str = self
-        end
+    m2 = Module.new do
+      refine String do
+        refinement_str = self
       end
+    end
 
-      Module.new do
-        using m1
-        using m2
+    Module.new do
+      using m1
+      using m2
 
-        Module.used_refinements.each { |r| ScratchPad << r }
-      end
-
-      ScratchPad.recorded.sort_by(&:object_id).should == [refinement_int, refinement_str].sort_by(&:object_id)
+      Module.used_refinements.each { |r| ScratchPad << r }
     end
 
-    it "returns empty array if does not have any refinements imported" do
-      used_refinements = nil
+    ScratchPad.recorded.sort_by(&:object_id).should == [refinement_int, refinement_str].sort_by(&:object_id)
+  end
 
-      Module.new do
-        used_refinements = Module.used_refinements
-      end
+  it "returns empty array if does not have any refinements imported" do
+    used_refinements = nil
 
-      used_refinements.should == []
+    Module.new do
+      used_refinements = Module.used_refinements
     end
 
-    it "ignores refinements imported in a module that is included into the current one" do
-      used_refinements = nil
+    used_refinements.should == []
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          nil
-        end
-      end
+  it "ignores refinements imported in a module that is included into the current one" do
+    used_refinements = nil
 
-      m2 = Module.new do
-        using m1
+    m1 = Module.new do
+      refine Integer do
+        nil
       end
+    end
 
-      Module.new do
-        include m2
+    m2 = Module.new do
+      using m1
+    end
 
-        used_refinements = Module.used_refinements
-      end
+    Module.new do
+      include m2
 
-      used_refinements.should == []
+      used_refinements = Module.used_refinements
     end
 
-    it "returns refinements even not defined directly in a module refinements are imported from" do
-      used_refinements = nil
-      ScratchPad.record []
+    used_refinements.should == []
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          ScratchPad << self
-        end
-      end
+  it "returns refinements even not defined directly in a module refinements are imported from" do
+    used_refinements = nil
+    ScratchPad.record []
 
-      m2 = Module.new do
-        include m1
+    m1 = Module.new do
+      refine Integer do
+        ScratchPad << self
       end
+    end
 
-      Module.new do
-        using m2
+    m2 = Module.new do
+      include m1
+    end
 
-        used_refinements = Module.used_refinements
-      end
+    Module.new do
+      using m2
 
-      used_refinements.should == ScratchPad.recorded
+      used_refinements = Module.used_refinements
     end
+
+    used_refinements.should == ScratchPad.recorded
   end
 end