Update specs for keyword argument separation

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

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

@@ -197,12 +197,22 @@ describe :io_new, shared: true do
     @io.internal_encoding.to_s.should == 'IBM866'
   end
 
+  ruby_version_is ''...'2.8' do
     it "accepts nil options" do
       @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
+  end
 
   it "coerces mode with #to_str" do
     mode = mock("mode")
@@ -372,6 +382,7 @@ describe :io_new_errors, shared: true do
     }.should raise_error(ArgumentError)
   end
 
+  ruby_version_is ''...'2.8' do
     it "raises TypeError if passed a hash for mode and nil for options" do
       -> {
         suppress_keyword_warning do
@@ -379,4 +390,13 @@ describe :io_new_errors, shared: true do
         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)
+      }.should raise_error(ArgumentError)
+    end
+  end
 end

spec/ruby/language/block_spec.rb

@@ -44,6 +44,7 @@ describe "A block yielded a single" do
       m([1, 2]) { |a, **k| [a, k] }.should == [1, {}]
     end
 
+    ruby_version_is ''..."2.8" 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] }
@@ -67,6 +68,29 @@ describe "A block yielded a single" do
           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], {x: 9}, 2, {}]
+      end
+
+      it "does not treat final Hash as keyword arguments" do
+        result = m(["a" => 1, a: 10]) { |a=nil, **b| [a, b] }
+        result.should == [{"a" => 1, a: 10}, {}]
+      end
+
+      it "does not call #to_hash on final argument to get keyword arguments" do
+        suppress_keyword_warning 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
+    end
 
     ruby_version_is ""..."2.7" do
       it "calls #to_hash on the argument and uses resulting hash as first argument when optional argument and keyword argument accepted" do
@@ -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,7 +112,18 @@ 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
+      ruby_version_is ""..."2.8" do
         it "separates non-symbol keys and symbol keys" do
           suppress_keyword_warning do
             result = m(["a" => 10, b: 2]) { |a=nil, **b| [a, b] }
@@ -96,12 +131,22 @@ describe "A block yielded a single" do
           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
 
     it "does not treat hashes with string keys as keyword arguments" do
       result = m(["a" => 10]) { |a = nil, **b| [a, b] }
       result.should == [{"a" => 10}, {}]
     end
 
+    ruby_version_is ''...'2.8' do
       it "calls #to_hash on the last element if keyword arguments are present" do
         suppress_keyword_warning do
           obj = mock("destructure block keyword arguments")
@@ -146,6 +191,25 @@ describe "A block yielded a single" do
 
         -> { m([1, 2, 3, obj]) { |a, *b, c, **k| } }.should raise_error(error)
       end
+    end
+
+    ruby_version_is '2.8' 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_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
+
+      it "does not call #to_hash on the last element when there are more arguments than parameters" do
+        x = mock("destructure matching block keyword argument")
+        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, {}]
+      end
+    end
 
     it "does not call #to_ary on the Array" do
       ary = [1, 2]

spec/ruby/language/lambda_spec.rb

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

spec/ruby/language/method_spec.rb

@@ -713,6 +713,7 @@ describe "A method" do
       end
     end
 
+    ruby_version_is ""..."2.8" do
       evaluate <<-ruby do
           def m(a, b: 1) [a, b] end
         ruby
@@ -745,6 +746,36 @@ describe "A method" do
           m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, {}]
         end
       end
+    end
+
+    ruby_version_is "2.8" do
+      evaluate <<-ruby do
+          def m(a, b: 1) [a, b] end
+        ruby
+
+        m(2).should == [2, 1]
+        m(1, b: 2).should == [1, 2]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
+      end
+
+      evaluate <<-ruby do
+          def m(a, **) a end
+        ruby
+
+        m(1).should == 1
+        m(1, a: 2, b: 3).should == 1
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
+      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
 
     evaluate <<-ruby do
         def m(a, &b) [a, b] end
@@ -854,6 +885,7 @@ describe "A method" do
       result.should == [[1, 2, 3], 4, [5, 6], 7, [], 8]
     end
 
+    ruby_version_is ""..."2.8" do
       evaluate <<-ruby do
           def m(a=1, b:) [a, b] end
         ruby
@@ -876,6 +908,28 @@ describe "A method" do
           m("a" => 1, b: 2).should == [{"a" => 1}, 2]
         end
       end
+    end
+
+    ruby_version_is "2.8" do
+      evaluate <<-ruby do
+          def m(a=1, b:) [a, b] end
+        ruby
+
+        m(b: 2).should == [1, 2]
+        m(2, b: 1).should == [2, 1]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
+      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]
+        -> { m("a" => 1, b: 2) }.should raise_error(ArgumentError)
+      end
+    end
 
     ruby_version_is ""..."2.7" do
       evaluate <<-ruby do
@@ -936,6 +990,7 @@ describe "A method" do
       m(1, 2, 3).should == [[1, 2], 3]
     end
 
+    ruby_version_is ""..."2.7" do
       evaluate <<-ruby do
           def m(*, a:) a end
         ruby
@@ -1006,7 +1061,6 @@ describe "A method" do
         -> { m(h) }.should raise_error(error)
       end
 
-    ruby_version_is ""..."2.7" do
       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,11 +1498,9 @@ 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}]
       end
     end
-    end
 
     evaluate <<-ruby do
         def m(a:, &b) [a, b] end
@@ -1361,6 +1596,7 @@ describe "A method" do
       result.should == [1, 1, [], 2, 3, 2, 4, { h: 5, i: 6 }, l]
     end
 
+    ruby_version_is ''...'2.8' do
       evaluate <<-ruby do
           def m(a, b = nil, c = nil, d, e: nil, **f)
             [a, b, c, d, e, f]
@@ -1380,6 +1616,26 @@ describe "A method" do
       end
     end
 
+    ruby_version_is '2.8' do
+      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
+
+  ruby_version_is ''...'2.8' do
     context "assigns keyword arguments from a passed Hash without modifying it" do
       evaluate <<-ruby do
           def m(a: nil); a; end
@@ -1394,6 +1650,21 @@ describe "A method" do
         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
 
 describe "A method call with a space between method name and parentheses" do

spec/ruby/optional/capi/util_spec.rb

@@ -115,12 +115,23 @@ describe "C-API Util function" do
       ScratchPad.recorded.should == [1, nil]
     end
 
+    ruby_version_is ''...'2.8' do
       it "assigns required and Hash arguments with nil Hash" do
         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
+    end
 
     it "assigns required and optional arguments with no hash argument given" do
       @o.rb_scan_args([1, 7, 4], "21:", 3, @acc).should == 3
@@ -133,6 +144,7 @@ describe "C-API Util function" do
       ScratchPad.recorded.should == [1, 2, [3, 4], 5, h, @prc]
     end
 
+    ruby_version_is ''...'2.8' do
       # r43934
       it "rejects non-keyword arguments" do
         h = {1 => 2, 3 => 4}
@@ -163,6 +175,27 @@ describe "C-API Util function" do
       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
+    end
+  end
+
   describe "rb_get_kwargs" do
     it "extracts required arguments in the order requested" do
       h = { :a => 7, :b => 5 }