1 files changed, 387 insertions, 116 deletions
diff --git a/spec/ruby/language/method_spec.rb b/spec/ruby/language/method_spec.rb
index 0486025792..f98e8569f8 100644
--- a/spec/ruby/language/method_spec.rb
+++ b/spec/ruby/language/method_spec.rb
@@ -713,36 +713,67 @@ describe "A method" do
       end
     end
 
-    evaluate <<-ruby do
-        def m(a, b: 1) [a, b] end
-      ruby
+    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]
-      suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, 1]
+        m(2).should == [2, 1]
+        m(1, b: 2).should == [1, 2]
+        suppress_keyword_warning do
+          m("a" => 1, b: 2).should == [{"a" => 1, b: 2}, 1]
+        end
       end
-    end
 
-    evaluate <<-ruby do
-        def m(a, **) a end
-      ruby
+      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}
+        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
-        def m(a, **k) [a, k] end
-      ruby
+    ruby_version_is "2.8" do
+      evaluate <<-ruby do
+          def m(a, b: 1) [a, b] 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}, {}]
+        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
 
@@ -854,26 +885,49 @@ describe "A method" do
       result.should == [[1, 2, 3], 4, [5, 6], 7, [], 8]
     end
 
-    evaluate <<-ruby do
-        def m(a=1, b:) [a, b] end
-      ruby
+    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]
-      suppress_keyword_warning do
-        m("a" => 1, b: 2).should == [{"a" => 1}, 2]
+        m(b: 2).should == [1, 2]
+        m(2, b: 1).should == [2, 1]
+        suppress_keyword_warning do
+          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
-        def m(a=1, b: 2) [a, b] end
-      ruby
+    ruby_version_is "2.8" do
+      evaluate <<-ruby do
+          def m(a=1, b:) [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]
+        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
 
@@ -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
+    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
+        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
-    end
 
-    evaluate <<-ruby do
-        def m(*a, b:) [a, b] end
-      ruby
+      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]
+        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
-    end
 
-    evaluate <<-ruby do
-        def m(*, a: 1) a end
-      ruby
+      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
+        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
-    end
 
-    evaluate <<-ruby do
-        def m(*a, b: 1) [a, b] end
-      ruby
+      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]
+        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
 
-      a = mock("splat")
-      a.should_not_receive(:to_ary)
-      m(*a).should == [[a], 1]
-    end
+      evaluate <<-ruby do
+          def m(*, **) end
+        ruby
 
-    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
 
-      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")
-      h.should_receive(:to_hash).and_return({a: 1})
-      suppress_keyword_warning do
-        m(h).should be_nil
+        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
 
-      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
@@ -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}]
-        end
+        m("a" => 1, a: 1, b: 2).should == [1, {"a" => 1, b: 2}]
       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
-        def m(a, b = nil, c = nil, d, e: nil, **f)
-          [a, b, c, d, e, f]
+    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, {}]
+
+        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.should == [1, nil, nil, 2, nil, {}]
+        result = m(1, {foo: :bar})
+        result.should == [1, nil, nil, {foo: :bar}, nil, {}]
+      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, {}]
 
-      suppress_warning do
         result = m(1, 2, {foo: :bar})
-        result.should == [1, nil, nil, 2, nil, {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
+        ruby
 
-      result = m(1, {foo: :bar})
-      result.should == [1, nil, nil, {foo: :bar}, nil, {}]
+        options = {a: 1}.freeze
+        -> do
+          suppress_warning do
+            m(options).should == 1
+          end
+        end.should_not raise_error
+        options.should == {a: 1}
+      end
     end
   end
 
-  context "assigns keyword arguments from a passed Hash without modifying it" do
-    evaluate <<-ruby do
-        def m(a: nil); a; end
-      ruby
+  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
-        suppress_warning do
-          m(options).should == 1
-        end
-      end.should_not raise_error
-      options.should == {a: 1}
+        options = {a: 1}.freeze
+        -> do
+          m(options)
+        end.should raise_error(ArgumentError)
+      end
     end
   end
 end