Update specs for keyword argument separation

Merged: https://github.com/ruby/ruby/pull/2794

spec/ruby/core/io/shared/new.rb

@@ -197,11 +197,21 @@ describe :io_new, shared: true do
     @io.internal_encoding.to_s.should == 'IBM866'
   end
 
-  it "accepts nil options" do
+  ruby_version_is ''...'2.8' do
-    @io = suppress_keyword_warning do
+    it "accepts nil options" do
-      IO.send(@method, @fd, 'w', nil)
+      @io = suppress_keyword_warning do
+        IO.send(@method, @fd, 'w', nil)
+      end
+      @io.write("foo").should == 3
+    end
+  end
+
+  ruby_version_is '2.8' do
+    it "raises ArgumentError for nil options" do
+      -> {
+        IO.send(@method, @fd, 'w', nil)
+      }.should raise_error(ArgumentError)
     end
-    @io.write("foo").should == 3
   end
 
   it "coerces mode with #to_str" do
@@ -372,11 +382,21 @@ describe :io_new_errors, shared: true do
     }.should raise_error(ArgumentError)
   end
 
-  it "raises TypeError if passed a hash for mode and nil for options" do
+  ruby_version_is ''...'2.8' do
-    -> {
+    it "raises TypeError if passed a hash for mode and nil for options" do
-      suppress_keyword_warning do
+      -> {
+        suppress_keyword_warning do
+          @io = IO.send(@method, @fd, {mode: 'w'}, nil)
+        end
+      }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is '2.8' do
+    it "raises ArgumentError if passed a hash for mode and nil for options" do
+      -> {
         @io = IO.send(@method, @fd, {mode: 'w'}, nil)
-      end
+      }.should raise_error(ArgumentError)
-    }.should raise_error(TypeError)
+    end
   end
 end

spec/ruby/language/block_spec.rb

@@ -44,27 +44,51 @@ describe "A block yielded a single" do
       m([1, 2]) { |a, **k| [a, k] }.should == [1, {}]
     end
 
-    it "assigns elements to mixed argument types" do
+    ruby_version_is ''..."2.8" do
-      suppress_keyword_warning do
+      it "assigns elements to mixed argument types" do
+        suppress_keyword_warning do
+          result = m([1, 2, 3, {x: 9}]) { |a, b=5, *c, d, e: 2, **k| [a, b, c, d, e, k] }
+          result.should == [1, 2, [], 3, 2, {x: 9}]
+        end
+      end
+
+      it "assigns symbol keys from a Hash to keyword arguments" do
+        suppress_keyword_warning do
+          result = m(["a" => 1, a: 10]) { |a=nil, **b| [a, b] }
+          result.should == [{"a" => 1}, a: 10]
+        end
+      end
+
+      it "assigns symbol keys from a Hash returned by #to_hash to keyword arguments" do
+        suppress_keyword_warning do
+          obj = mock("coerce block keyword arguments")
+          obj.should_receive(:to_hash).and_return({"a" => 1, b: 2})
+
+          result = m([obj]) { |a=nil, **b| [a, b] }
+          result.should == [{"a" => 1}, b: 2]
+        end
+      end
+    end
+
+    ruby_version_is "2.8" do
+      it "assigns elements to mixed argument types" do
         result = m([1, 2, 3, {x: 9}]) { |a, b=5, *c, d, e: 2, **k| [a, b, c, d, e, k] }
-        result.should == [1, 2, [], 3, 2, {x: 9}]
+        result.should == [1, 2, [3], {x: 9}, 2, {}]
       end
-    end
 
-    it "assigns symbol keys from a Hash to keyword arguments" do
+      it "does not treat final Hash as keyword arguments" do
-      suppress_keyword_warning do
         result = m(["a" => 1, a: 10]) { |a=nil, **b| [a, b] }
-        result.should == [{"a" => 1}, a: 10]
+        result.should == [{"a" => 1, a: 10}, {}]
       end
-    end
 
-    it "assigns symbol keys from a Hash returned by #to_hash to keyword arguments" do
+      it "does not call #to_hash on final argument to get keyword arguments" do
-      suppress_keyword_warning do
+        suppress_keyword_warning do
-        obj = mock("coerce block keyword arguments")
+          obj = mock("coerce block keyword arguments")
-        obj.should_receive(:to_hash).and_return({"a" => 1, b: 2})
+          obj.should_not_receive(:to_hash)
 
-        result = m([obj]) { |a=nil, **b| [a, b] }
+          result = m([obj]) { |a=nil, **b| [a, b] }
-        result.should == [{"a" => 1}, b: 2]
+          result.should == [obj, {}]
+        end
       end
     end
 
@@ -78,7 +102,7 @@ describe "A block yielded a single" do
       end
     end
 
-    ruby_version_is "2.7" do
+    ruby_version_is "2.7"...'2.8' do
       it "calls #to_hash on the argument but ignores result when optional argument and keyword argument accepted" do
         obj = mock("coerce block keyword arguments")
         obj.should_receive(:to_hash).and_return({"a" => 1, "b" => 2})
@@ -88,11 +112,31 @@ describe "A block yielded a single" do
       end
     end
 
+    ruby_version_is "2.8" do
+      it "does not call #to_hash on the argument when optional argument and keyword argument accepted" do
+        obj = mock("coerce block keyword arguments")
+        obj.should_not_receive(:to_hash)
+
+        result = m([obj]) { |a=nil, **b| [a, b] }
+        result.should == [obj, {}]
+      end
+    end
+
     describe "when non-symbol keys are in a keyword arguments Hash" do
-      it "separates non-symbol keys and symbol keys" do
+      ruby_version_is ""..."2.8" do
-        suppress_keyword_warning do
+        it "separates non-symbol keys and symbol keys" do
-          result = m(["a" => 10, b: 2]) { |a=nil, **b| [a, b] }
+          suppress_keyword_warning do
-          result.should == [{"a" => 10}, {b: 2}]
+            result = m(["a" => 10, b: 2]) { |a=nil, **b| [a, b] }
+            result.should == [{"a" => 10}, {b: 2}]
+          end
+        end
+      end
+      ruby_version_is "2.8" do
+        it "does not separates non-symbol keys and symbol keys" do
+          suppress_keyword_warning do
+            result = m(["a" => 10, b: 2]) { |a=nil, **b| [a, b] }
+            result.should == [{"a" => 10, b: 2}, {}]
+          end
         end
       end
     end
@@ -102,51 +146,71 @@ describe "A block yielded a single" do
       result.should == [{"a" => 10}, {}]
     end
 
-    it "calls #to_hash on the last element if keyword arguments are present" do
+    ruby_version_is ''...'2.8' do
-      suppress_keyword_warning do
+      it "calls #to_hash on the last element if keyword arguments are present" do
-        obj = mock("destructure block keyword arguments")
+        suppress_keyword_warning do
-        obj.should_receive(:to_hash).and_return({x: 9})
+          obj = mock("destructure block keyword arguments")
+          obj.should_receive(:to_hash).and_return({x: 9})
 
-        result = m([1, 2, 3, obj]) { |a, *b, c, **k| [a, b, c, k] }
+          result = m([1, 2, 3, obj]) { |a, *b, c, **k| [a, b, c, k] }
-        result.should == [1, [2], 3, {x: 9}]
+          result.should == [1, [2], 3, {x: 9}]
+        end
+      end
+
+      it "assigns the last element to a non-keyword argument if #to_hash returns nil" do
+        suppress_keyword_warning do
+          obj = mock("destructure block keyword arguments")
+          obj.should_receive(:to_hash).and_return(nil)
+
+          result = m([1, 2, 3, obj]) { |a, *b, c, **k| [a, b, c, k] }
+          result.should == [1, [2, 3], obj, {}]
+        end
+      end
+
+      it "calls #to_hash on the last element when there are more arguments than parameters" do
+        suppress_keyword_warning do
+          x = mock("destructure matching block keyword argument")
+          x.should_receive(:to_hash).and_return({x: 9})
+
+          result = m([1, 2, 3, {y: 9}, 4, 5, x]) { |a, b=5, c, **k| [a, b, c, k] }
+          result.should == [1, 2, 3, {x: 9}]
+        end
+      end
+
+      it "raises a TypeError if #to_hash does not return a Hash" do
+        obj = mock("destructure block keyword arguments")
+        obj.should_receive(:to_hash).and_return(1)
+
+        -> { m([1, 2, 3, obj]) { |a, *b, c, **k| } }.should raise_error(TypeError)
+      end
+
+      it "raises the error raised inside #to_hash" do
+        obj = mock("destructure block keyword arguments")
+        error = RuntimeError.new("error while converting to a hash")
+        obj.should_receive(:to_hash).and_raise(error)
+
+        -> { m([1, 2, 3, obj]) { |a, *b, c, **k| } }.should raise_error(error)
       end
     end
 
-    it "assigns the last element to a non-keyword argument if #to_hash returns nil" do
+    ruby_version_is '2.8' do
-      suppress_keyword_warning do
+      it "does not call #to_hash on the last element if keyword arguments are present" do
         obj = mock("destructure block keyword arguments")
-        obj.should_receive(:to_hash).and_return(nil)
+        obj.should_not_receive(:to_hash)
 
         result = m([1, 2, 3, obj]) { |a, *b, c, **k| [a, b, c, k] }
         result.should == [1, [2, 3], obj, {}]
       end
-    end
 
-    it "calls #to_hash on the last element when there are more arguments than parameters" do
+      it "does not call #to_hash on the last element when there are more arguments than parameters" do
-      suppress_keyword_warning do
         x = mock("destructure matching block keyword argument")
-        x.should_receive(:to_hash).and_return({x: 9})
+        x.should_not_receive(:to_hash)
 
         result = m([1, 2, 3, {y: 9}, 4, 5, x]) { |a, b=5, c, **k| [a, b, c, k] }
-        result.should == [1, 2, 3, {x: 9}]
+        result.should == [1, 2, 3, {}]
       end
     end
 
-    it "raises a TypeError if #to_hash does not return a Hash" do
-      obj = mock("destructure block keyword arguments")
-      obj.should_receive(:to_hash).and_return(1)
-
-      -> { m([1, 2, 3, obj]) { |a, *b, c, **k| } }.should raise_error(TypeError)
-    end
-
-    it "raises the error raised inside #to_hash" do
-      obj = mock("destructure block keyword arguments")
-      error = RuntimeError.new("error while converting to a hash")
-      obj.should_receive(:to_hash).and_raise(error)
-
-      -> { m([1, 2, 3, obj]) { |a, *b, c, **k| } }.should raise_error(error)
-    end
-
     it "does not call #to_ary on the Array" do
       ary = [1, 2]
       ary.should_not_receive(:to_ary)

spec/ruby/language/lambda_spec.rb

@@ -179,17 +179,33 @@ describe "A lambda literal -> () { }" do
       result.should == [1, 2, 3, [4, 5], 6, [7, 8], 9, 10, 11, 12]
     end
 
-    evaluate <<-ruby do
+    ruby_version_is ''...'2.8' do
-        @a = -> (*, **k) { k }
+      evaluate <<-ruby do
-      ruby
+          @a = -> (*, **k) { k }
+        ruby
 
-      @a.().should == {}
+        @a.().should == {}
-      @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+
+        suppress_keyword_warning do
+          h = mock("keyword splat")
+          h.should_receive(:to_hash).and_return({a: 1})
+          @a.(h).should == {a: 1}
+        end
+      end
+    end
+
+    ruby_version_is '2.8' do
+      evaluate <<-ruby do
+          @a = -> (*, **k) { k }
+        ruby
+
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
 
-      suppress_keyword_warning do
         h = mock("keyword splat")
-        h.should_receive(:to_hash).and_return({a: 1})
+        h.should_not_receive(:to_hash)
-        @a.(h).should == {a: 1}
+        @a.(h).should == {}
       end
     end
 
@@ -533,17 +549,33 @@ describe "A lambda expression 'lambda { ... }'" do
       result.should == [1, 2, 3, [4, 5], 6, [7, 8], 9, 10, 11, 12]
     end
 
-    evaluate <<-ruby do
+    ruby_version_is ''...'2.8' do
-        @a = lambda { |*, **k| k }
+      evaluate <<-ruby do
-      ruby
+          @a = lambda { |*, **k| k }
+        ruby
 
-      @a.().should == {}
+        @a.().should == {}
-      @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+
+        suppress_keyword_warning do
+          h = mock("keyword splat")
+          h.should_receive(:to_hash).and_return({a: 1})
+          @a.(h).should == {a: 1}
+        end
+      end
+    end
+
+    ruby_version_is '2.8' do
+      evaluate <<-ruby do
+          @a = lambda { |*, **k| k }
+        ruby
+
+        @a.().should == {}
+        @a.(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
 
-      suppress_keyword_warning do
         h = mock("keyword splat")
-        h.should_receive(:to_hash).and_return({a: 1})
+        h.should_not_receive(:to_hash)
-        @a.(h).should == {a: 1}
+        @a.(h).should == {}
       end
     end
 

spec/ruby/language/method_spec.rb

@@ -713,36 +713,67 @@ describe "A method" do
       end
     end
 
-    evaluate <<-ruby do
+    ruby_version_is ""..."2.8" do
-        def m(a, b: 1) [a, b] end
+      evaluate <<-ruby do
-      ruby
+          def m(a, b: 1) [a, b] end
+        ruby
 
-      m(2).should == [2, 1]
+        m(2).should == [2, 1]
-      m(1, b: 2).should == [1, 2]
+        m(1, b: 2).should == [1, 2]
-      suppress_keyword_warning do
+        suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, 1]
+          m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, 1]
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(a, **) a end
+        ruby
+
+        m(1).should == 1
+        m(1, a: 2, b: 3).should == 1
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == {"a" => 1, b: 2}
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(a, **k) [a, k] end
+        ruby
+
+        m(1).should == [1, {}]
+        m(1, a: 2, b: 3).should == [1, {a: 2, b: 3}]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, {}]
+        end
       end
     end
 
-    evaluate <<-ruby do
+    ruby_version_is "2.8" do
-        def m(a, **) a end
+      evaluate <<-ruby do
-      ruby
+          def m(a, b: 1) [a, b] end
+        ruby
 
-      m(1).should == 1
+        m(2).should == [2, 1]
-      m(1, a: 2, b: 3).should == 1
+        m(1, b: 2).should == [1, 2]
-      suppress_keyword_warning do
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
-        m("a" => 1, b: 2).should == {"a" => 1, b: 2}
       end
-    end
 
-    evaluate <<-ruby do
+      evaluate <<-ruby do
-        def m(a, **k) [a, k] end
+          def m(a, **) a end
-      ruby
+        ruby
 
-      m(1).should == [1, {}]
+        m(1).should == 1
-      m(1, a: 2, b: 3).should == [1, {a: 2, b: 3}]
+        m(1, a: 2, b: 3).should == 1
-      suppress_keyword_warning do
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
-        m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, {}]
+      end
+
+      evaluate <<-ruby do
+          def m(a, **k) [a, k] end
+        ruby
+
+        m(1).should == [1, {}]
+        m(1, a: 2, b: 3).should == [1, {a: 2, b: 3}]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
       end
     end
 
@@ -854,26 +885,49 @@ describe "A method" do
       result.should == [[1, 2, 3], 4, [5, 6], 7, [], 8]
     end
 
-    evaluate <<-ruby do
+    ruby_version_is ""..."2.8" do
-        def m(a=1, b:) [a, b] end
+      evaluate <<-ruby do
-      ruby
+          def m(a=1, b:) [a, b] end
+        ruby
 
-      m(b: 2).should == [1, 2]
+        m(b: 2).should == [1, 2]
-      m(2, b: 1).should == [2, 1]
+        m(2, b: 1).should == [2, 1]
-      suppress_keyword_warning do
+        suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [{"a" => 1}, 2]
+          m("a" => 1, b: 2).should == [{"a" => 1}, 2]
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(a=1, b: 2) [a, b] end
+        ruby
+
+        m().should == [1, 2]
+        m(2).should == [2, 2]
+        m(b: 3).should == [1, 3]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [{"a" => 1}, 2]
+        end
       end
     end
 
-    evaluate <<-ruby do
+    ruby_version_is "2.8" do
-        def m(a=1, b: 2) [a, b] end
+      evaluate <<-ruby do
-      ruby
+          def m(a=1, b:) [a, b] end
+        ruby
 
-      m().should == [1, 2]
+        m(b: 2).should == [1, 2]
-      m(2).should == [2, 2]
+        m(2, b: 1).should == [2, 1]
-      m(b: 3).should == [1, 3]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
-      suppress_keyword_warning do
+      end
-        m("a" => 1, b: 2).should == [{"a" => 1}, 2]
+
+      evaluate <<-ruby do
+          def m(a=1, b: 2) [a, b] end
+        ruby
+
+        m().should == [1, 2]
+        m(2).should == [2, 2]
+        m(b: 3).should == [1, 3]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
       end
     end
 
@@ -936,77 +990,77 @@ describe "A method" do
       m(1, 2, 3).should == [[1, 2], 3]
     end
 
-    evaluate <<-ruby do
-        def m(*, a:) a end
-      ruby
-
-      m(a: 1).should == 1
-      m(1, 2, a: 3).should == 3
-      suppress_keyword_warning do
-        m("a" => 1, a: 2).should == 2
-      end
-    end
-
-    evaluate <<-ruby do
-        def m(*a, b:) [a, b] end
-      ruby
-
-      m(b: 1).should == [[], 1]
-      m(1, 2, b: 3).should == [[1, 2], 3]
-      suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
-      end
-    end
-
-    evaluate <<-ruby do
-        def m(*, a: 1) a end
-      ruby
-
-      m().should == 1
-      m(1, 2).should == 1
-      m(a: 2).should == 2
-      m(1, a: 2).should == 2
-      suppress_keyword_warning do
-        m("a" => 1, a: 2).should == 2
-      end
-    end
-
-    evaluate <<-ruby do
-        def m(*a, b: 1) [a, b] end
-      ruby
-
-      m().should == [[], 1]
-      m(1, 2, 3, b: 4).should == [[1, 2, 3], 4]
-      suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
-      end
-
-      a = mock("splat")
-      a.should_not_receive(:to_ary)
-      m(*a).should == [[a], 1]
-    end
-
-    evaluate <<-ruby do
-        def m(*, **) end
-      ruby
-
-      m().should be_nil
-      m(a: 1, b: 2).should be_nil
-      m(1, 2, 3, a: 4, b: 5).should be_nil
-
-      h = mock("keyword splat")
-      h.should_receive(:to_hash).and_return({a: 1})
-      suppress_keyword_warning do
-        m(h).should be_nil
-      end
-
-      h = mock("keyword splat")
-      error = RuntimeError.new("error while converting to a hash")
-      h.should_receive(:to_hash).and_raise(error)
-      -> { m(h) }.should raise_error(error)
-    end
-
     ruby_version_is ""..."2.7" do
+      evaluate <<-ruby do
+          def m(*, a:) a end
+        ruby
+
+        m(a: 1).should == 1
+        m(1, 2, a: 3).should == 3
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b:) [a, b] end
+        ruby
+
+        m(b: 1).should == [[], 1]
+        m(1, 2, b: 3).should == [[1, 2], 3]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*, a: 1) a end
+        ruby
+
+        m().should == 1
+        m(1, 2).should == 1
+        m(a: 2).should == 2
+        m(1, a: 2).should == 2
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b: 1) [a, b] end
+        ruby
+
+        m().should == [[], 1]
+        m(1, 2, 3, b: 4).should == [[1, 2, 3], 4]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+
+        a = mock("splat")
+        a.should_not_receive(:to_ary)
+        m(*a).should == [[a], 1]
+      end
+
+      evaluate <<-ruby do
+          def m(*, **) end
+        ruby
+
+        m().should be_nil
+        m(a: 1, b: 2).should be_nil
+        m(1, 2, 3, a: 4, b: 5).should be_nil
+
+        h = mock("keyword splat")
+        h.should_receive(:to_hash).and_return({a: 1})
+        suppress_keyword_warning do
+          m(h).should be_nil
+        end
+
+        h = mock("keyword splat")
+        error = RuntimeError.new("error while converting to a hash")
+        h.should_receive(:to_hash).and_raise(error)
+        -> { m(h) }.should raise_error(error)
+      end
+
       evaluate <<-ruby do
           def m(*a, **) a end
         ruby
@@ -1093,7 +1147,57 @@ describe "A method" do
       end
     end
 
-    ruby_version_is "2.7" do
+    ruby_version_is "2.7"...'2.8' do
+      evaluate <<-ruby do
+          def m(*, a:) a end
+        ruby
+
+        m(a: 1).should == 1
+        m(1, 2, a: 3).should == 3
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b:) [a, b] end
+        ruby
+
+        m(b: 1).should == [[], 1]
+        m(1, 2, b: 3).should == [[1, 2], 3]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*, a: 1) a end
+        ruby
+
+        m().should == 1
+        m(1, 2).should == 1
+        m(a: 2).should == 2
+        m(1, a: 2).should == 2
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b: 1) [a, b] end
+        ruby
+
+        m().should == [[], 1]
+        m(1, 2, 3, b: 4).should == [[1, 2, 3], 4]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+
+        a = mock("splat")
+        a.should_not_receive(:to_ary)
+        m(*a).should == [[a], 1]
+      end
+
       evaluate <<-ruby do
           def m(*a, **) a end
         ruby
@@ -1184,6 +1288,139 @@ describe "A method" do
 
         m(*bo, **bo).should == [[1, 2, 3], {:b => 2, :c => 3}]
       end
+
+      evaluate <<-ruby do
+          def m(*, a:) a end
+        ruby
+
+        m(a: 1).should == 1
+        m(1, 2, a: 3).should == 3
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b:) [a, b] end
+        ruby
+
+        m(b: 1).should == [[], 1]
+        m(1, 2, b: 3).should == [[1, 2], 3]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*, a: 1) a end
+        ruby
+
+        m().should == 1
+        m(1, 2).should == 1
+        m(a: 2).should == 2
+        m(1, a: 2).should == 2
+        suppress_keyword_warning do
+          m("a" => 1, a: 2).should == 2
+        end
+      end
+
+      evaluate <<-ruby do
+          def m(*a, b: 1) [a, b] end
+        ruby
+
+        m().should == [[], 1]
+        m(1, 2, 3, b: 4).should == [[1, 2, 3], 4]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [[{"a" => 1}], 2]
+        end
+
+        a = mock("splat")
+        a.should_not_receive(:to_ary)
+        m(*a).should == [[a], 1]
+      end
+
+      evaluate <<-ruby do
+          def m(*a, **) a end
+        ruby
+
+        m().should == []
+        m(1, 2, 3, a: 4, b: 5).should == [1, 2, 3]
+        m("a" => 1, a: 1).should == []
+        m(1, **{a: 2}).should == [1]
+
+        h = mock("keyword splat")
+        h.should_receive(:to_hash)
+        -> { m(**h) }.should raise_error(TypeError)
+      end
+
+      evaluate <<-ruby do
+          def m(*, **k) k end
+        ruby
+
+        m().should == {}
+        m(1, 2, 3, a: 4, b: 5).should == {a: 4, b: 5}
+        m("a" => 1, a: 1).should == {"a" => 1, a: 1}
+
+        h = mock("keyword splat")
+        h.should_receive(:to_hash).and_return({a: 1})
+        m(h).should == {}
+      end
+
+      evaluate <<-ruby do
+          def m(a = nil, **k) [a, k] end
+        ruby
+
+        m().should == [nil, {}]
+        m("a" => 1).should == [nil, {"a" => 1}]
+        m(a: 1).should == [nil, {a: 1}]
+        m("a" => 1, a: 1).should == [nil, {"a" => 1, a: 1}]
+        m({ "a" => 1 }, a: 1).should == [{"a" => 1}, {a: 1}]
+        ->{m({a: 1}, {})}.should raise_error(ArgumentError)
+
+        h = {"a" => 1, b: 2}
+        m(h).should == [{"a" => 1, b: 2}, {}]
+        h.should == {"a" => 1, b: 2}
+
+        h = {"a" => 1}
+        m(h).first.should == h
+
+        h = {}
+        r = m(h)
+        r.first.should == {}
+        r.last.should == {}
+
+        hh = {}
+        h = mock("keyword splat empty hash")
+        h.should_not_receive(:to_hash)
+        m(h).should == [{}, {}]
+
+        h = mock("keyword splat")
+        h.should_not_receive(:to_hash)
+        m(h).should == [{"a" => 1, a: 2}, {}]
+      end
+
+      evaluate <<-ruby do
+          def m(*a, **k) [a, k] end
+        ruby
+
+        m().should == [[], {}]
+        m(1).should == [[1], {}]
+        m(a: 1, b: 2).should == [[], {a: 1, b: 2}]
+        m(1, 2, 3, a: 2).should == [[1, 2, 3], {a: 2}]
+
+        m("a" => 1).should == [[], {"a" => 1}]
+        m(a: 1).should == [[], {a: 1}]
+        m("a" => 1, a: 1).should == [[], {"a" => 1, a: 1}]
+        m({ "a" => 1 }, a: 1).should == [[{"a" => 1}], {a: 1}]
+        m({a: 1}, {}).should == [[{a: 1}, {}], {}]
+        m({a: 1}, {"a" => 1}).should == [[{a: 1}, {"a" => 1}], {}]
+
+        bo = BasicObject.new
+        def bo.to_a; [1, 2, 3]; end
+        def bo.to_hash; {:b => 2, :c => 3}; end
+
+        m(*bo, **bo).should == [[1, 2, 3], {:b => 2, :c => 3}]
+      end
     end
 
     evaluate <<-ruby do
@@ -1261,9 +1498,7 @@ describe "A method" do
 
         m(a: 1).should == [1, {}]
         m(a: 1, b: 2, c: 3).should == [1, {b: 2, c: 3}]
-        suppress_warning do
+        m("a" => 1, a: 1, b: 2).should == [1, {"a" => 1, b: 2}]
-          m("a" => 1, a: 1, b: 2).should == [1, {"a" => 1, b: 2}]
-        end
       end
     end
 
@@ -1361,37 +1596,73 @@ describe "A method" do
       result.should == [1, 1, [], 2, 3, 2, 4, { h: 5, i: 6 }, l]
     end
 
-    evaluate <<-ruby do
+    ruby_version_is ''...'2.8' do
-        def m(a, b = nil, c = nil, d, e: nil, **f)
+      evaluate <<-ruby do
-          [a, b, c, d, e, f]
+          def m(a, b = nil, c = nil, d, e: nil, **f)
+            [a, b, c, d, e, f]
+          end
+        ruby
+
+        result = m(1, 2)
+        result.should == [1, nil, nil, 2, nil, {}]
+
+        suppress_warning do
+          result = m(1, 2, {foo: :bar})
+          result.should == [1, nil, nil, 2, nil, {foo: :bar}]
         end
-      ruby
 
-      result = m(1, 2)
+        result = m(1, {foo: :bar})
-      result.should == [1, nil, nil, 2, nil, {}]
+        result.should == [1, nil, nil, {foo: :bar}, nil, {}]
-
-      suppress_warning do
-        result = m(1, 2, {foo: :bar})
-        result.should == [1, nil, nil, 2, nil, {foo: :bar}]
       end
+    end
 
-      result = m(1, {foo: :bar})
+    ruby_version_is '2.8' do
-      result.should == [1, nil, nil, {foo: :bar}, nil, {}]
+      evaluate <<-ruby do
+          def m(a, b = nil, c = nil, d, e: nil, **f)
+            [a, b, c, d, e, f]
+          end
+        ruby
+
+        result = m(1, 2)
+        result.should == [1, nil, nil, 2, nil, {}]
+
+        result = m(1, 2, {foo: :bar})
+        result.should == [1, 2, nil, {foo: :bar}, nil, {}]
+
+        result = m(1, {foo: :bar})
+        result.should == [1, nil, nil, {foo: :bar}, nil, {}]
+      end
     end
   end
 
-  context "assigns keyword arguments from a passed Hash without modifying it" do
+  ruby_version_is ''...'2.8' do
-    evaluate <<-ruby do
+    context "assigns keyword arguments from a passed Hash without modifying it" do
-        def m(a: nil); a; end
+      evaluate <<-ruby do
-      ruby
+          def m(a: nil); a; end
+        ruby
 
-      options = {a: 1}.freeze
+        options = {a: 1}.freeze
-      -> do
+        -> do
-        suppress_warning do
+          suppress_warning do
-          m(options).should == 1
+            m(options).should == 1
-        end
+          end
-      end.should_not raise_error
+        end.should_not raise_error
-      options.should == {a: 1}
+        options.should == {a: 1}
+      end
+    end
+  end
+
+  ruby_version_is '2.8' do
+    context "raises ArgumentError if passing hash as keyword arguments" do
+      evaluate <<-ruby do
+          def m(a: nil); a; end
+        ruby
+
+        options = {a: 1}.freeze
+        -> do
+          m(options)
+        end.should raise_error(ArgumentError)
+      end
     end
   end
 end

spec/ruby/optional/capi/util_spec.rb

@@ -115,11 +115,22 @@ describe "C-API Util function" do
       ScratchPad.recorded.should == [1, nil]
     end
 
-    it "assigns required and Hash arguments with nil Hash" do
+    ruby_version_is ''...'2.8' do
-      suppress_warning do
+      it "assigns required and Hash arguments with nil Hash" do
-        @o.rb_scan_args([1, nil], "1:", 2, @acc).should == 1
+        suppress_warning do
+          @o.rb_scan_args([1, nil], "1:", 2, @acc).should == 1
+        end
+        ScratchPad.recorded.should == [1, nil]
+      end
+    end
+
+    ruby_version_is '2.8' do
+      it "rejects the use of nil as a hash" do
+        -> {
+          @o.rb_scan_args([1, nil], "1:", 2, @acc).should == 1
+        }.should raise_error(ArgumentError)
+        ScratchPad.recorded.should == []
       end
-      ScratchPad.recorded.should == [1, nil]
     end
 
     it "assigns required and optional arguments with no hash argument given" do
@@ -133,33 +144,55 @@ describe "C-API Util function" do
       ScratchPad.recorded.should == [1, 2, [3, 4], 5, h, @prc]
     end
 
-    # r43934
+    ruby_version_is ''...'2.8' do
-    it "rejects non-keyword arguments" do
+      # r43934
-      h = {1 => 2, 3 => 4}
+      it "rejects non-keyword arguments" do
-      -> {
+        h = {1 => 2, 3 => 4}
-        suppress_warning do
+        -> {
-          @o.rb_scan_args([h], "#{@keyword_prefix}0:", 1, @acc)
+          suppress_warning do
-        end
+            @o.rb_scan_args([h], "#{@keyword_prefix}0:", 1, @acc)
-      }.should raise_error(ArgumentError)
+          end
-      ScratchPad.recorded.should == []
+        }.should raise_error(ArgumentError)
-    end
+        ScratchPad.recorded.should == []
-
+      end
-    it "rejects required and non-keyword arguments" do
+
-      h = {1 => 2, 3 => 4}
+      it "rejects required and non-keyword arguments" do
-      -> {
+        h = {1 => 2, 3 => 4}
-        suppress_warning do
+        -> {
-          @o.rb_scan_args([1, h], "#{@keyword_prefix}1:", 2, @acc)
+          suppress_warning do
-        end
+            @o.rb_scan_args([1, h], "#{@keyword_prefix}1:", 2, @acc)
-      }.should raise_error(ArgumentError)
+          end
-      ScratchPad.recorded.should == []
+        }.should raise_error(ArgumentError)
-    end
+        ScratchPad.recorded.should == []
-
+      end
-    it "considers the hash as a post argument when there is a splat" do
+
-      h = {1 => 2, 3 => 4}
+      it "considers the hash as a post argument when there is a splat" do
-      suppress_warning do
+        h = {1 => 2, 3 => 4}
-        @o.rb_scan_args([1, 2, 3, 4, 5, h], "#{@keyword_prefix}11*1:&", 6, @acc, &@prc).should == 6
+        suppress_warning do
+          @o.rb_scan_args([1, 2, 3, 4, 5, h], "#{@keyword_prefix}11*1:&", 6, @acc, &@prc).should == 6
+        end
+        ScratchPad.recorded.should == [1, 2, [3, 4, 5], h, nil, @prc]
+      end
+    end
+
+    ruby_version_is '2.8' do
+      it "does not reject non-symbol keys in keyword arguments" do
+        h = {1 => 2, 3 => 4}
+        @o.rb_scan_args([h], "#{@keyword_prefix}0:", 1, @acc).should == 0
+        ScratchPad.recorded.should == [h]
+      end
+
+      it "does not reject non-symbol keys in keyword arguments with required argument" do
+        h = {1 => 2, 3 => 4}
+        @o.rb_scan_args([1, h], "#{@keyword_prefix}1:", 2, @acc).should == 1
+        ScratchPad.recorded.should == [1, h]
+      end
+
+      it "considers keyword arguments with non-symbol keys as keywords when using splat and post arguments" do
+        h = {1 => 2, 3 => 4}
+        @o.rb_scan_args([1, 2, 3, 4, 5, h], "#{@keyword_prefix}11*1:&", 6, @acc, &@prc).should == 5
+        ScratchPad.recorded.should == [1, 2, [3, 4], 5, h, @prc]
       end
-      ScratchPad.recorded.should == [1, 2, [3, 4, 5], h, nil, @prc]
     end
   end