1 files changed, 190 insertions, 104 deletions

diff --git a/spec/ruby/core/module/autoload_spec.rb b/spec/ruby/core/module/autoload_spec.rb
index f17675846b..057237a92f 100644
--- a/spec/ruby/core/module/autoload_spec.rb
+++ b/spec/ruby/core/module/autoload_spec.rb
@@ -1,7 +1,6 @@
 require_relative '../../spec_helper'
 require_relative '../../fixtures/code_loading'
 require_relative 'fixtures/classes'
-require 'thread'
 
 describe "Module#autoload?" do
   it "returns the name of the file that will be autoloaded" do
@@ -10,7 +9,7 @@ describe "Module#autoload?" do
   end
 
   it "returns nil if no file has been registered for a constant" do
-    ModuleSpecs::Autoload.autoload?(:Manualload).should be_nil
+    ModuleSpecs::Autoload.autoload?(:Manualload).should == nil
   end
 
   it "returns the name of the file that will be autoloaded if an ancestor defined that autoload" do
@@ -18,16 +17,14 @@ describe "Module#autoload?" do
     ModuleSpecs::Autoload::Child.autoload?(:AnotherAutoload).should == "another_autoload.rb"
   end
 
-  ruby_version_is "2.7" do
-    it "returns nil if an ancestor defined that autoload but recursion is disabled" do
-      ModuleSpecs::Autoload::Parent.autoload :InheritedAutoload, "inherited_autoload.rb"
-      ModuleSpecs::Autoload::Child.autoload?(:InheritedAutoload, false).should be_nil
-    end
+  it "returns nil if an ancestor defined that autoload but recursion is disabled" do
+    ModuleSpecs::Autoload::Parent.autoload :InheritedAutoload, "inherited_autoload.rb"
+    ModuleSpecs::Autoload::Child.autoload?(:InheritedAutoload, false).should == nil
+  end
 
-    it "returns the name of the file that will be loaded if recursion is disabled but the autoload is defined on the class itself" do
-      ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"
-      ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"
-    end
+  it "returns the name of the file that will be loaded if recursion is disabled but the autoload is defined on the class itself" do
+    ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"
+    ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"
   end
 end
 
@@ -58,7 +55,7 @@ describe "Module#autoload" do
 
   it "sets the autoload constant in the constants table" do
     ModuleSpecs::Autoload.autoload :B, @non_existent
-    ModuleSpecs::Autoload.should have_constant(:B)
+    ModuleSpecs::Autoload.should.const_defined?(:B, false)
   end
 
   it "can be overridden with a second autoload on the same constant" do
@@ -74,7 +71,7 @@ describe "Module#autoload" do
   end
 
   it "loads the registered constant when it is accessed" do
-    ModuleSpecs::Autoload.should_not have_constant(:X)
+    ModuleSpecs::Autoload.should_not.const_defined?(:X)
     ModuleSpecs::Autoload.autoload :X, fixture(__FILE__, "autoload_x.rb")
     @remove << :X
     ModuleSpecs::Autoload::X.should == :x
@@ -85,7 +82,7 @@ describe "Module#autoload" do
     ModuleSpecs::Autoload::DynClass = cls
     @remove << :DynClass
 
-    ScratchPad.recorded.should be_nil
+    ScratchPad.recorded.should == nil
     ModuleSpecs::Autoload::DynClass::C.new.loaded.should == :dynclass_c
     ScratchPad.recorded.should == :loaded
   end
@@ -95,7 +92,7 @@ describe "Module#autoload" do
     ModuleSpecs::Autoload::DynModule = mod
     @remove << :DynModule
 
-    ScratchPad.recorded.should be_nil
+    ScratchPad.recorded.should == nil
     ModuleSpecs::Autoload::DynModule::D.new.loaded.should == :dynmodule_d
     ScratchPad.recorded.should == :loaded
   end
@@ -134,7 +131,7 @@ describe "Module#autoload" do
     @remove << :I
     ModuleSpecs::Autoload.const_set :I, 3
     ModuleSpecs::Autoload::I.should == 3
-    ScratchPad.recorded.should be_nil
+    ScratchPad.recorded.should == nil
   end
 
   it "loads a file with .rb extension when passed the name without the extension" do
@@ -147,7 +144,7 @@ describe "Module#autoload" do
     main = TOPLEVEL_BINDING.eval("self")
     main.should_receive(:require).with("module_autoload_not_exist.rb")
     # The constant won't be defined since require is mocked to do nothing
-    -> { ModuleSpecs::Autoload::ModuleAutoloadCallsRequire }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload::ModuleAutoloadCallsRequire }.should.raise(NameError)
   end
 
   it "does not load the file if the file is manually required" do
@@ -159,9 +156,9 @@ describe "Module#autoload" do
     ScratchPad.recorded.should == :loaded
     ScratchPad.clear
 
-    ModuleSpecs::Autoload::KHash.should be_kind_of(Class)
+    ModuleSpecs::Autoload::KHash.should.is_a?(Class)
     ModuleSpecs::Autoload::KHash::K.should == :autoload_k
-    ScratchPad.recorded.should be_nil
+    ScratchPad.recorded.should == nil
   end
 
   it "ignores the autoload request if the file is already loaded" do
@@ -174,7 +171,7 @@ describe "Module#autoload" do
 
     ModuleSpecs::Autoload.autoload :S, filename
     @remove << :S
-    ModuleSpecs::Autoload.autoload?(:S).should be_nil
+    ModuleSpecs::Autoload.autoload?(:S).should == nil
   end
 
   it "retains the autoload even if the request to require fails" do
@@ -185,7 +182,7 @@ describe "Module#autoload" do
 
     -> {
       require filename
-    }.should raise_error(LoadError)
+    }.should.raise(LoadError)
 
     ModuleSpecs::Autoload.autoload?(:NotThere).should == filename
   end
@@ -208,7 +205,7 @@ describe "Module#autoload" do
     filename = fixture(__FILE__, "autoload_during_require_current_file.rb")
     require filename
 
-    ScratchPad.recorded.should be_nil
+    ScratchPad.recorded.should == nil
   end
 
   describe "interacting with defined?" do
@@ -218,9 +215,9 @@ describe "Module#autoload" do
       end
 
       defined?(ModuleSpecs::Autoload::Dog::R).should == "constant"
-      ScratchPad.recorded.should be_nil
+      ScratchPad.recorded.should == nil
 
-      ModuleSpecs::Autoload::Dog.should have_constant(:R)
+      ModuleSpecs::Autoload::Dog.should.const_defined?(:R, false)
     end
 
     it "loads an autoloaded parent when referencing a nested constant" do
@@ -238,7 +235,7 @@ describe "Module#autoload" do
         autoload :BadParent, fixture(__FILE__, "autoload_exception.rb")
       end
 
-      defined?(ModuleSpecs::Autoload::BadParent::Nested).should be_nil
+      defined?(ModuleSpecs::Autoload::BadParent::Nested).should == nil
       ScratchPad.recorded.should == :exception
     end
   end
@@ -345,6 +342,29 @@ describe "Module#autoload" do
     end
   end
 
+  def check_before_during_thread_after(const, &check)
+    before = check.call
+    to_autoload_thread, from_autoload_thread = Queue.new, Queue.new
+    ScratchPad.record -> {
+      from_autoload_thread.push check.call
+      to_autoload_thread.pop
+    }
+    t = Thread.new {
+      in_loading_thread = from_autoload_thread.pop
+      in_other_thread = check.call
+      to_autoload_thread.push :done
+      [in_loading_thread, in_other_thread]
+    }
+    in_loading_thread, in_other_thread = nil
+    begin
+      ModuleSpecs::Autoload.const_get(const)
+    ensure
+      in_loading_thread, in_other_thread = t.value
+    end
+    after = check.call
+    [before, in_loading_thread, in_other_thread, after]
+  end
+
   describe "during the autoload before the constant is assigned" do
     before :each do
       @path = fixture(__FILE__, "autoload_during_autoload.rb")
@@ -353,72 +373,97 @@ describe "Module#autoload" do
       raise unless ModuleSpecs::Autoload.autoload?(:DuringAutoload) == @path
     end
 
-    def check_before_during_thread_after(&check)
-      before = check.call
-      to_autoload_thread, from_autoload_thread = Queue.new, Queue.new
-      ScratchPad.record -> {
-        from_autoload_thread.push check.call
-        to_autoload_thread.pop
-      }
-      t = Thread.new {
-        in_loading_thread = from_autoload_thread.pop
-        in_other_thread = check.call
-        to_autoload_thread.push :done
-        [in_loading_thread, in_other_thread]
-      }
-      in_loading_thread, in_other_thread = nil
-      begin
-        ModuleSpecs::Autoload::DuringAutoload
-      ensure
-        in_loading_thread, in_other_thread = t.value
-      end
-      after = check.call
-      [before, in_loading_thread, in_other_thread, after]
-    end
-
     it "returns nil in autoload thread and 'constant' otherwise for defined?" do
-      results = check_before_during_thread_after {
+      results = check_before_during_thread_after(:DuringAutoload) {
         defined?(ModuleSpecs::Autoload::DuringAutoload)
       }
       results.should == ['constant', nil, 'constant', 'constant']
     end
 
     it "keeps the constant in Module#constants" do
-      results = check_before_during_thread_after {
+      results = check_before_during_thread_after(:DuringAutoload) {
         ModuleSpecs::Autoload.constants(false).include?(:DuringAutoload)
       }
       results.should == [true, true, true, true]
     end
 
     it "returns false in autoload thread and true otherwise for Module#const_defined?" do
-      results = check_before_during_thread_after {
+      results = check_before_during_thread_after(:DuringAutoload) {
         ModuleSpecs::Autoload.const_defined?(:DuringAutoload, false)
       }
       results.should == [true, false, true, true]
     end
 
     it "returns nil in autoload thread and returns the path in other threads for Module#autoload?" do
-      results = check_before_during_thread_after {
+      results = check_before_during_thread_after(:DuringAutoload) {
         ModuleSpecs::Autoload.autoload?(:DuringAutoload)
       }
       results.should == [@path, nil, @path, nil]
     end
   end
 
+  describe "during the autoload after the constant is assigned" do
+    before :each do
+      @path = fixture(__FILE__, "autoload_during_autoload_after_define.rb")
+      ModuleSpecs::Autoload.autoload :DuringAutoloadAfterDefine, @path
+      @autoload_location = [__FILE__, __LINE__ - 1]
+      @const_location = [@path, 2]
+      @remove << :DuringAutoloadAfterDefine
+      raise unless ModuleSpecs::Autoload.autoload?(:DuringAutoloadAfterDefine) == @path
+    end
+
+    it "returns 'constant' in both threads" do
+      results = check_before_during_thread_after(:DuringAutoloadAfterDefine) {
+        defined?(ModuleSpecs::Autoload::DuringAutoloadAfterDefine)
+      }
+      results.should == ['constant', 'constant', 'constant', 'constant']
+    end
+
+    it "Module#constants include the autoloaded in both threads" do
+      results = check_before_during_thread_after(:DuringAutoloadAfterDefine) {
+        ModuleSpecs::Autoload.constants(false).include?(:DuringAutoloadAfterDefine)
+      }
+      results.should == [true, true, true, true]
+    end
+
+    it "Module#const_defined? returns true in both threads" do
+      results = check_before_during_thread_after(:DuringAutoloadAfterDefine) {
+        ModuleSpecs::Autoload.const_defined?(:DuringAutoloadAfterDefine, false)
+      }
+      results.should == [true, true, true, true]
+    end
+
+    it "returns nil in autoload thread and returns the path in other threads for Module#autoload?" do
+      results = check_before_during_thread_after(:DuringAutoloadAfterDefine) {
+        ModuleSpecs::Autoload.autoload?(:DuringAutoloadAfterDefine)
+      }
+      results.should == [@path, nil, @path, nil]
+    end
+
+    ruby_bug("#20188", ""..."3.4") do
+      it "returns the real constant location in autoload thread and returns the autoload location in other threads for Module#const_source_location" do
+        results = check_before_during_thread_after(:DuringAutoloadAfterDefine) {
+          ModuleSpecs::Autoload.const_source_location(:DuringAutoloadAfterDefine)
+        }
+        results.should == [@autoload_location, @const_location, @autoload_location, @const_location]
+      end
+    end
+  end
+
   it "does not remove the constant from Module#constants if load fails and keeps it as an autoload" do
     ModuleSpecs::Autoload.autoload :Fail, @non_existent
 
     ModuleSpecs::Autoload.const_defined?(:Fail).should == true
-    ModuleSpecs::Autoload.should have_constant(:Fail)
+    ModuleSpecs::Autoload.should.const_defined?(:Fail, false)
     ModuleSpecs::Autoload.autoload?(:Fail).should == @non_existent
 
-    -> { ModuleSpecs::Autoload::Fail }.should raise_error(LoadError)
+    -> { ModuleSpecs::Autoload::Fail }.should.raise(LoadError)
 
-    ModuleSpecs::Autoload.should have_constant(:Fail)
+    ModuleSpecs::Autoload.should.const_defined?(:Fail, false)
     ModuleSpecs::Autoload.const_defined?(:Fail).should == true
     ModuleSpecs::Autoload.autoload?(:Fail).should == @non_existent
 
-    -> { ModuleSpecs::Autoload::Fail }.should raise_error(LoadError)
+    -> { ModuleSpecs::Autoload::Fail }.should.raise(LoadError)
   end
 
   it "does not remove the constant from Module#constants if load raises a RuntimeError and keeps it as an autoload" do
@@ -427,35 +472,35 @@ describe "Module#autoload" do
     ModuleSpecs::Autoload.autoload :Raise, path
 
     ModuleSpecs::Autoload.const_defined?(:Raise).should == true
-    ModuleSpecs::Autoload.should have_constant(:Raise)
+    ModuleSpecs::Autoload.should.const_defined?(:Raise, false)
     ModuleSpecs::Autoload.autoload?(:Raise).should == path
 
-    -> { ModuleSpecs::Autoload::Raise }.should raise_error(RuntimeError)
+    -> { ModuleSpecs::Autoload::Raise }.should.raise(RuntimeError)
     ScratchPad.recorded.should == [:raise]
 
-    ModuleSpecs::Autoload.should have_constant(:Raise)
+    ModuleSpecs::Autoload.should.const_defined?(:Raise, false)
     ModuleSpecs::Autoload.const_defined?(:Raise).should == true
     ModuleSpecs::Autoload.autoload?(:Raise).should == path
 
-    -> { ModuleSpecs::Autoload::Raise }.should raise_error(RuntimeError)
+    -> { ModuleSpecs::Autoload::Raise }.should.raise(RuntimeError)
     ScratchPad.recorded.should == [:raise, :raise]
   end
 
-  it "does not remove the constant from Module#constants if the loaded file does not define it, but leaves it as 'undefined'" do
+  it "removes the constant from Module#constants if the loaded file does not define it" do
     path = fixture(__FILE__, "autoload_o.rb")
     ScratchPad.record []
     ModuleSpecs::Autoload.autoload :O, path
 
     ModuleSpecs::Autoload.const_defined?(:O).should == true
-    ModuleSpecs::Autoload.should have_constant(:O)
+    ModuleSpecs::Autoload.should.const_defined?(:O, false)
     ModuleSpecs::Autoload.autoload?(:O).should == path
 
-    -> { ModuleSpecs::Autoload::O }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload::O }.should.raise(NameError)
 
-    ModuleSpecs::Autoload.should have_constant(:O)
     ModuleSpecs::Autoload.const_defined?(:O).should == false
+    ModuleSpecs::Autoload.should_not.const_defined?(:O)
     ModuleSpecs::Autoload.autoload?(:O).should == nil
-    -> { ModuleSpecs::Autoload.const_get(:O) }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload.const_get(:O) }.should.raise(NameError)
   end
 
   it "does not try to load the file again if the loaded file did not define the constant" do
@@ -463,13 +508,13 @@ describe "Module#autoload" do
     ScratchPad.record []
     ModuleSpecs::Autoload.autoload :NotDefinedByFile, path
 
-    -> { ModuleSpecs::Autoload::NotDefinedByFile }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload::NotDefinedByFile }.should.raise(NameError)
     ScratchPad.recorded.should == [:loaded]
-    -> { ModuleSpecs::Autoload::NotDefinedByFile }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload::NotDefinedByFile }.should.raise(NameError)
     ScratchPad.recorded.should == [:loaded]
 
     Thread.new {
-      -> { ModuleSpecs::Autoload::NotDefinedByFile }.should raise_error(NameError)
+      -> { ModuleSpecs::Autoload::NotDefinedByFile }.should.raise(NameError)
     }.join
     ScratchPad.recorded.should == [:loaded]
   end
@@ -479,7 +524,7 @@ describe "Module#autoload" do
       autoload :R, fixture(__FILE__, "autoload.rb")
       defined?(R).should == 'constant'
     end
-    ModuleSpecs::Autoload::Q.should have_constant(:R)
+    ModuleSpecs::Autoload::Q.should.const_defined?(:R, false)
   end
 
   it "does not load the file when removing an autoload constant" do
@@ -487,15 +532,13 @@ describe "Module#autoload" do
       autoload :R, fixture(__FILE__, "autoload.rb")
       remove_const :R
     end
-    ModuleSpecs::Autoload::Q.should_not have_constant(:R)
+    ModuleSpecs::Autoload::Q.should_not.const_defined?(:R)
   end
 
   it "does not load the file when accessing the constants table of the module" do
     ModuleSpecs::Autoload.autoload :P, @non_existent
-    ModuleSpecs::Autoload.const_defined?(:P).should be_true
-    ruby_bug "[Bug #15780]", ""..."2.7" do
-      ModuleSpecs::Autoload.const_defined?("P").should be_true
-    end
+    ModuleSpecs::Autoload.const_defined?(:P).should == true
+    ModuleSpecs::Autoload.const_defined?("P").should == true
   end
 
   it "loads the file when opening a module that is the autoloaded constant" do
@@ -530,8 +573,8 @@ describe "Module#autoload" do
           DeclaredAndDefinedInParent.should == :declared_and_defined_in_parent
 
           # The constant is really in Autoload, not Autoload::LexicalScope
-          self.should_not have_constant(:DeclaredAndDefinedInParent)
-          -> { const_get(:DeclaredAndDefinedInParent) }.should raise_error(NameError)
+          self.should_not.const_defined?(:DeclaredAndDefinedInParent)
+          -> { const_get(:DeclaredAndDefinedInParent) }.should.raise(NameError)
         end
         DeclaredAndDefinedInParent.should == :declared_and_defined_in_parent
       end
@@ -554,14 +597,41 @@ describe "Module#autoload" do
         # Basically, the parent autoload constant remains in a "undefined" state
         self.autoload?(:DeclaredInParentDefinedInCurrent).should == nil
         const_defined?(:DeclaredInParentDefinedInCurrent).should == false
-        self.should have_constant(:DeclaredInParentDefinedInCurrent)
-        -> { DeclaredInParentDefinedInCurrent }.should raise_error(NameError)
+        -> { DeclaredInParentDefinedInCurrent }.should.raise(NameError)
 
         ModuleSpecs::Autoload::LexicalScope.send(:remove_const, :DeclaredInParentDefinedInCurrent)
       end
     end
 
-    it "and fails when finding the undefined autoload constant in the current scope when declared in current and defined in parent" 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
+      }
+
+      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
+
+    it "looks up in parent scope after failed autoload" do
       @remove << :DeclaredInCurrentDefinedInParent
       module ModuleSpecs::Autoload
         ScratchPad.record -> {
@@ -570,12 +640,11 @@ describe "Module#autoload" do
 
         class LexicalScope
           autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
-          -> { DeclaredInCurrentDefinedInParent }.should raise_error(NameError)
+          -> { DeclaredInCurrentDefinedInParent }.should_not.raise(NameError)
           # Basically, the autoload constant remains in a "undefined" state
           self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
           const_defined?(:DeclaredInCurrentDefinedInParent).should == false
-          self.should have_constant(:DeclaredInCurrentDefinedInParent)
-          -> { const_get(:DeclaredInCurrentDefinedInParent) }.should raise_error(NameError)
+          -> { const_get(:DeclaredInCurrentDefinedInParent) }.should.raise(NameError)
         end
 
         DeclaredInCurrentDefinedInParent.should == :declared_in_current_defined_in_parent
@@ -645,10 +714,25 @@ describe "Module#autoload" do
           end
         end
       end
-      ModuleSpecs::Autoload.r.should be_kind_of(ModuleSpecs::Autoload::MetaScope)
+      ModuleSpecs::Autoload.r.should.is_a?(ModuleSpecs::Autoload::MetaScope)
     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 == nil
+
+      DynClass::C.new.loaded.should == :dynclass_c
+      ScratchPad.recorded.should == :loaded
+    end
+
+    -> { ModuleSpecs::Autoload::DynClass }.should.raise(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
@@ -661,7 +745,7 @@ describe "Module#autoload" do
     end
     @remove << :W
 
-    ModuleSpecs::Autoload::W::Y.should be_kind_of(Class)
+    ModuleSpecs::Autoload::W::Y.should.is_a?(Class)
     ScratchPad.recorded.should == :loaded
   end
 
@@ -676,7 +760,7 @@ describe "Module#autoload" do
     -> {
       Kernel.require fixture(__FILE__, "autoload_during_require.rb")
     }.should_not complain(verbose: true)
-    ModuleSpecs::Autoload::AutoloadDuringRequire.should be_kind_of(Class)
+    ModuleSpecs::Autoload::AutoloadDuringRequire.should.is_a?(Class)
   end
 
   it "does not call #require a second time and does not warn if feature sets and trigger autoload on itself" do
@@ -686,15 +770,15 @@ describe "Module#autoload" do
     -> {
       Kernel.require fixture(__FILE__, "autoload_self_during_require.rb")
     }.should_not complain(verbose: true)
-    ModuleSpecs::Autoload::AutoloadSelfDuringRequire.should be_kind_of(Class)
+    ModuleSpecs::Autoload::AutoloadSelfDuringRequire.should.is_a?(Class)
   end
 
   it "handles multiple autoloads in the same file" do
     $LOAD_PATH.unshift(File.expand_path('../fixtures/multi', __FILE__))
     begin
       require 'foo/bar_baz'
-      ModuleSpecs::Autoload::Foo::Bar.should be_kind_of(Class)
-      ModuleSpecs::Autoload::Foo::Baz.should be_kind_of(Class)
+      ModuleSpecs::Autoload::Foo::Bar.should.is_a?(Class)
+      ModuleSpecs::Autoload::Foo::Baz.should.is_a?(Class)
     ensure
       $LOAD_PATH.shift
     end
@@ -707,19 +791,19 @@ describe "Module#autoload" do
   end
 
   it "raises an ArgumentError when an empty filename is given" do
-    -> { ModuleSpecs.autoload :A, "" }.should raise_error(ArgumentError)
+    -> { ModuleSpecs.autoload :A, "" }.should.raise(ArgumentError)
   end
 
   it "raises a NameError when the constant name starts with a lower case letter" do
-    -> { ModuleSpecs.autoload "a", @non_existent }.should raise_error(NameError)
+    -> { ModuleSpecs.autoload "a", @non_existent }.should.raise(NameError)
   end
 
   it "raises a NameError when the constant name starts with a number" do
-    -> { ModuleSpecs.autoload "1two", @non_existent }.should raise_error(NameError)
+    -> { ModuleSpecs.autoload "1two", @non_existent }.should.raise(NameError)
   end
 
   it "raises a NameError when the constant name has a space in it" do
-    -> { ModuleSpecs.autoload "a name", @non_existent }.should raise_error(NameError)
+    -> { ModuleSpecs.autoload "a name", @non_existent }.should.raise(NameError)
   end
 
   it "shares the autoload request across dup'ed copies of modules" do
@@ -736,7 +820,7 @@ describe "Module#autoload" do
     mod2.autoload?(:T).should == filename
 
     mod1::T.should == :autoload_t
-    -> { mod2::T }.should raise_error(NameError)
+    -> { mod2::T }.should.raise(NameError)
   end
 
   it "raises a TypeError if opening a class with a different superclass than the class defined in the autoload file" do
@@ -747,27 +831,27 @@ describe "Module#autoload" do
     -> do
       class ModuleSpecs::Autoload::Z < ModuleSpecs::Autoload::ZZ
       end
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError)
   end
 
   it "raises a TypeError if not passed a String or object responding to #to_path for the filename" do
     name = mock("autoload_name.rb")
 
-    -> { ModuleSpecs::Autoload.autoload :Str, name }.should raise_error(TypeError)
+    -> { ModuleSpecs::Autoload.autoload :Str, name }.should.raise(TypeError)
   end
 
   it "calls #to_path on non-String filename arguments" do
     name = mock("autoload_name.rb")
     name.should_receive(:to_path).and_return("autoload_name.rb")
 
-    -> { ModuleSpecs::Autoload.autoload :Str, name }.should_not raise_error
+    -> { ModuleSpecs::Autoload.autoload :Str, name }.should_not.raise
   end
 
   describe "on a frozen module" do
     it "raises a FrozenError before setting the name" do
       frozen_module = Module.new.freeze
-      -> { frozen_module.autoload :Foo, @non_existent }.should raise_error(FrozenError)
-      frozen_module.should_not have_constant(:Foo)
+      -> { frozen_module.autoload :Foo, @non_existent }.should.raise(FrozenError)
+      frozen_module.should_not.const_defined?(:Foo)
     end
   end
 
@@ -832,7 +916,7 @@ describe "Module#autoload" do
       t1_val.should == 1
       t2_val.should == t1_val
 
-      t2_exc.should be_nil
+      t2_exc.should == nil
     end
 
     # https://bugs.ruby-lang.org/issues/10892
@@ -864,7 +948,7 @@ describe "Module#autoload" do
 
             begin
               Object.const_get(mod_name).foo
-            rescue NoMethodError
+            rescue NameError, NoMethodError # rubocop:disable Lint/ShadowedException
               barrier.disable!
               break false
             end
@@ -872,8 +956,8 @@ describe "Module#autoload" do
         end
       end
 
-      # check that no thread got a NoMethodError because of partially loaded module
-      threads.all? {|t| t.value}.should be_true
+      # check that no thread got a NameError or NoMethodError because of partially loaded module
+      threads.all? {|t| t.value}.should == true
 
       # check that the autoloaded file was evaled exactly once
       ScratchPad.recorded.get.should == mod_count
@@ -881,6 +965,8 @@ describe "Module#autoload" do
       mod_names.each do |mod_name|
         Object.send(:remove_const, mod_name)
       end
+    ensure
+      threads.each(&:join) if threads
     end
 
     it "raises a NameError in each thread if the constant is not set" do
@@ -904,7 +990,7 @@ describe "Module#autoload" do
 
       start = true
       threads.each { |t|
-        t.value.should be_an_instance_of(NameError)
+        t.value.should.instance_of?(NameError)
       }
     end
 
@@ -929,7 +1015,7 @@ describe "Module#autoload" do
 
       start = true
       threads.each { |t|
-        t.value.should be_an_instance_of(LoadError)
+        t.value.should.instance_of?(LoadError)
       }
     end
   end