1 files changed, 215 insertions, 34 deletions
diff --git a/spec/ruby/language/method_spec.rb b/spec/ruby/language/method_spec.rb
index 9abe4cde20..8f72bd45ed 100644
--- a/spec/ruby/language/method_spec.rb
+++ b/spec/ruby/language/method_spec.rb
@@ -1175,6 +1175,31 @@ describe "A method" do
   end
 end
 
+context "when passing **nil into a method that accepts keyword arguments" do
+  ruby_version_is ""..."3.4" do
+    it "raises TypeError" do
+      def m(**kw) kw; end
+
+      h = nil
+      -> { m(a: 1, **h) }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+      -> { m(a: 1, **nil) }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "expands nil using ** into {}" do
+      def m(**kw) kw; end
+
+      h = nil
+      m(**h).should == {}
+      m(a: 1, **h).should == {a: 1}
+
+      m(**nil).should == {}
+      m(a: 1, **nil).should == {a: 1}
+    end
+  end
+end
+
 describe "A method call with a space between method name and parentheses" do
   before(:each) do
     def m(*args)
@@ -1416,53 +1441,209 @@ describe "Keyword arguments are now separated from positional arguments" do
   end
 end
 
-ruby_version_is "3.1" do
-  describe "kwarg with omitted value in a method call" do
-    context "accepts short notation 'kwarg' in method call" do
-      evaluate <<-ruby do
-          def call(*args, **kwargs) = [args, kwargs]
-        ruby
+describe "kwarg with omitted value in a method call" do
+  context "accepts short notation 'kwarg' in method call" do
+    evaluate <<-ruby do
+        def call(*args, **kwargs) = [args, kwargs]
+      ruby
+
+      a, b, c = 1, 2, 3
+      arr, h = call(a:)
+      h.should == {a: 1}
+      arr.should == []
+
+      arr, h = call(a:, b:, c:)
+      h.should == {a: 1, b: 2, c: 3}
+      arr.should == []
+
+      arr, h = call(a:, b: 10, c:)
+      h.should == {a: 1, b: 10, c: 3}
+      arr.should == []
+    end
+  end
+
+  context "with methods and local variables" do
+    evaluate <<-ruby do
+        def call(*args, **kwargs) = [args, kwargs]
+
+        def bar
+          "baz"
+        end
+
+        def foo(val)
+          call bar:, val:
+        end
+      ruby
 
-        a, b, c = 1, 2, 3
-        arr, h = eval('call a:')
-        h.should == {a: 1}
-        arr.should == []
+      foo(1).should == [[], {bar: "baz", val: 1}]
+    end
+  end
+end
 
-        arr, h = eval('call(a:, b:, c:)')
-        h.should == {a: 1, b: 2, c: 3}
-        arr.should == []
+describe "Inside 'endless' method definitions" do
+  it "allows method calls without parenthesis" do
+    def greet(person) = "Hi, ".dup.concat person
 
-        arr, h = eval('call(a:, b: 10, c:)')
-        h.should == {a: 1, b: 10, c: 3}
-        arr.should == []
+    greet("Homer").should == "Hi, Homer"
+  end
+end
+
+describe "warning about not used block argument" do
+  ruby_version_is "3.4" do
+    it "warns when passing a block argument to a method that never uses it" do
+      def m_that_does_not_use_block
+        42
       end
+
+      -> {
+        m_that_does_not_use_block { }
+      }.should complain(
+        /#{__FILE__}:#{__LINE__ - 2}: warning: the block passed to 'm_that_does_not_use_block' defined at #{__FILE__}:#{__LINE__ - 7} may be ignored/,
+        verbose: true)
     end
 
-    context "with methods and local variables" do
-      evaluate <<-ruby do
-          def call(*args, **kwargs) = [args, kwargs]
+    it "does not warn when passing a block argument to a method that declares a block parameter" do
+      def m_with_block_parameter(&block)
+        42
+      end
 
-          def bar
-            "baz"
-          end
+      -> { m_with_block_parameter { } }.should_not complain(verbose: true)
+    end
 
-          def foo(val)
-            call bar:, val:
-          end
-        ruby
+    it "does not warn when passing a block argument to a method that declares an anonymous block parameter" do
+      def m_with_anonymous_block_parameter(&)
+        42
+      end
+
+      -> { m_with_anonymous_block_parameter { } }.should_not complain(verbose: true)
+    end
 
-        foo(1).should == [[], {bar: "baz", val: 1}]
+    it "does not warn when passing a block argument to a method that yields an implicit block parameter" do
+      def m_with_yield
+        yield 42
       end
+
+      -> { m_with_yield { } }.should_not complain(verbose: true)
     end
-  end
 
-  describe "Inside 'endless' method definitions" do
-    it "allows method calls without parenthesis" do
-      eval <<-ruby
-        def greet(person) = "Hi, ".dup.concat person
-      ruby
+    it "warns when passing a block argument to a method that calls #block_given?" do
+      def m_with_block_given
+        block_given?
+      end
+
+      -> {
+        m_with_block_given { }
+      }.should complain(
+        /#{__FILE__}:#{__LINE__ - 2}: warning: the block passed to 'm_with_block_given' defined at #{__FILE__}:#{__LINE__ - 7} may be ignored/,
+        verbose: true)
+    end
+
+    it "does not warn when passing a block argument to a method that calls super" do
+      parent = Class.new do
+        def m
+        end
+      end
+
+      child = Class.new(parent) do
+        def m
+          super
+        end
+      end
+
+      obj = child.new
+      -> { obj.m { } }.should_not complain(verbose: true)
+    end
+
+    it "does not warn when passing a block argument to a method that calls super(...)" do
+      parent = Class.new do
+        def m(a)
+        end
+      end
+
+      child = Class.new(parent) do
+        def m(...)
+          super(...)
+        end
+      end
+
+      obj = child.new
+      -> { obj.m(42) { } }.should_not complain(verbose: true)
+    end
+
+    it "does not warn when called #initialize()" do
+      klass = Class.new do
+        def initialize
+        end
+      end
+
+      -> { klass.new {} }.should_not complain(verbose: true)
+    end
+
+    it "does not warn when passing a block argument to a method that calls super()" do
+      parent = Class.new do
+        def m
+        end
+      end
 
-      greet("Homer").should == "Hi, Homer"
+      child = Class.new(parent) do
+        def m
+          super()
+        end
+      end
+
+      obj = child.new
+      -> { obj.m { } }.should_not complain(verbose: true)
+    end
+
+    it "warns only once per call site" do
+      def m_that_does_not_use_block
+        42
+      end
+
+      def call_m_that_does_not_use_block
+        m_that_does_not_use_block {}
+      end
+
+      -> {
+        m_that_does_not_use_block { }
+      }.should complain(/the block passed to 'm_that_does_not_use_block' defined at .+ may be ignored/, verbose: true)
+
+      -> {
+        m_that_does_not_use_block { }
+      }.should_not complain(verbose: true)
+    end
+
+    it "can be disabled with :strict_unused_block warning category" do
+      def m_that_does_not_use_block
+        42
+      end
+
+      # ensure that warning is emitted
+      -> { m_that_does_not_use_block { } }.should complain(verbose: true)
+
+      warn_strict_unused_block = Warning[:strict_unused_block]
+      Warning[:strict_unused_block] = false
+      begin
+        -> { m_that_does_not_use_block { } }.should_not complain(verbose: true)
+      ensure
+        Warning[:strict_unused_block] = warn_strict_unused_block
+      end
+    end
+
+    it "can be enabled with :strict_unused_block = true warning category in not verbose mode" do
+      def m_that_does_not_use_block
+        42
+      end
+
+      warn_strict_unused_block = Warning[:strict_unused_block]
+      Warning[:strict_unused_block] = true
+      begin
+        -> {
+          m_that_does_not_use_block { }
+      }.should complain(/the block passed to 'm_that_does_not_use_block' defined at .+ may be ignored/)
+      ensure
+        Warning[:strict_unused_block] = warn_strict_unused_block
+      end
     end
   end
 end