[Bug #20218] Reject keyword arguments in index

1 files changed, 106 insertions, 110 deletions

diff --git a/test/ruby/test_call.rb b/test/ruby/test_call.rb
index 09146efa41..d5fe9ce320 100644
--- a/test/ruby/test_call.rb
+++ b/test/ruby/test_call.rb
@@ -133,125 +133,127 @@ class TestCall < Test::Unit::TestCase
     kw = {}
     b = lambda{}
 
+    message = /keyword arg given in index/
+
     # +=, without block, non-popped
-    assert_equal([[], {}, nil, [4], {}, nil], h.v{h[**kw] += 1})
-    assert_equal([[0], {}, nil, [0, 4], {}, nil], h.v{h[0, **kw] += 1})
-    assert_equal([[0], {}, nil, [0, 4], {}, nil], h.v{h[0, *a, **kw] += 1})
-    assert_equal([[], {kw: 5}, nil, [4], {kw: 5}, nil], h.v{h[kw: 5] += 1})
-    assert_equal([[], {kw: 5, a: 2}, nil, [4], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] += 1})
-    assert_equal([[], {kw: 5, a: 2}, nil, [4], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] += 1})
-    assert_equal([[0], {kw: 5, a: 2}, nil, [0, 4], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] += 1})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil, [0, 4], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] += 1})
+    assert_syntax_error(%q{h[**kw] += 1}, message)
+    assert_syntax_error(%q{h[0, **kw] += 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] += 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] += 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] += 1}, message)
 
     # +=, with block, non-popped
-    assert_equal([[], {}, b, [4], {}, b], h.v{h[**kw, &b] += 1})
-    assert_equal([[0], {}, b, [0, 4], {}, b], h.v{h[0, **kw, &b] += 1})
-    assert_equal([[0], {}, b, [0, 4], {}, b], h.v{h[0, *a, **kw, &b] += 1})
-    assert_equal([[], {kw: 5}, b, [4], {kw: 5}, b], h.v{h[kw: 5, &b] += 1})
-    assert_equal([[], {kw: 5, a: 2}, b, [4], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] += 1})
-    assert_equal([[], {kw: 5, a: 2}, b, [4], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] += 1})
-    assert_equal([[0], {kw: 5, a: 2}, b, [0, 4], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] += 1})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b, [0, 4], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] += 1})
+    assert_syntax_error(%q{h[**kw, &b] += 1}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] += 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] += 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] += 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] += 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] += 1}, message)
 
     # +=, without block, popped
-    assert_equal([[], {}, nil, [4], {}, nil], h.v{h[**kw] += 1; nil})
-    assert_equal([[0], {}, nil, [0, 4], {}, nil], h.v{h[0, **kw] += 1; nil})
-    assert_equal([[0], {}, nil, [0, 4], {}, nil], h.v{h[0, *a, **kw] += 1; nil})
-    assert_equal([[], {kw: 5}, nil, [4], {kw: 5}, nil], h.v{h[kw: 5] += 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil, [4], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] += 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil, [4], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] += 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, nil, [0, 4], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] += 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil, [0, 4], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] += 1; nil})
+    assert_syntax_error(%q{h[**kw] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] += 1; nil}, message)
 
     # +=, with block, popped
-    assert_equal([[], {}, b, [4], {}, b], h.v{h[**kw, &b] += 1; nil})
-    assert_equal([[0], {}, b, [0, 4], {}, b], h.v{h[0, **kw, &b] += 1; nil})
-    assert_equal([[0], {}, b, [0, 4], {}, b], h.v{h[0, *a, **kw, &b] += 1; nil})
-    assert_equal([[], {kw: 5}, b, [4], {kw: 5}, b], h.v{h[kw: 5, &b] += 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b, [4], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] += 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b, [4], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] += 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, b, [0, 4], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] += 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b, [0, 4], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] += 1; nil})
+    assert_syntax_error(%q{h[**kw, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] += 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] += 1; nil}, message)
 
     # &&=, without block, non-popped
-    assert_equal([[], {}, nil, [1], {}, nil], h.v{h[**kw] &&= 1})
-    assert_equal([[0], {}, nil, [0, 1], {}, nil], h.v{h[0, **kw] &&= 1})
-    assert_equal([[0], {}, nil, [0, 1], {}, nil], h.v{h[0, *a, **kw] &&= 1})
-    assert_equal([[], {kw: 5}, nil, [1], {kw: 5}, nil], h.v{h[kw: 5] &&= 1})
-    assert_equal([[], {kw: 5, a: 2}, nil, [1], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] &&= 1})
-    assert_equal([[], {kw: 5, a: 2}, nil, [1], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] &&= 1})
-    assert_equal([[0], {kw: 5, a: 2}, nil, [0, 1], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] &&= 1})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil, [0, 1], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] &&= 1})
+    assert_syntax_error(%q{h[**kw] &&= 1}, message)
+    assert_syntax_error(%q{h[0, **kw] &&= 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] &&= 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] &&= 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] &&= 1}, message)
 
     # &&=, with block, non-popped
-    assert_equal([[], {}, b, [1], {}, b], h.v{h[**kw, &b] &&= 1})
-    assert_equal([[0], {}, b, [0, 1], {}, b], h.v{h[0, **kw, &b] &&= 1})
-    assert_equal([[0], {}, b, [0, 1], {}, b], h.v{h[0, *a, **kw, &b] &&= 1})
-    assert_equal([[], {kw: 5}, b, [1], {kw: 5}, b], h.v{h[kw: 5, &b] &&= 1})
-    assert_equal([[], {kw: 5, a: 2}, b, [1], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] &&= 1})
-    assert_equal([[], {kw: 5, a: 2}, b, [1], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] &&= 1})
-    assert_equal([[0], {kw: 5, a: 2}, b, [0, 1], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] &&= 1})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b, [0, 1], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] &&= 1})
+    assert_syntax_error(%q{h[**kw, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] &&= 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] &&= 1}, message)
 
     # &&=, without block, popped
-    assert_equal([[], {}, nil, [1], {}, nil], h.v{h[**kw] &&= 1; nil})
-    assert_equal([[0], {}, nil, [0, 1], {}, nil], h.v{h[0, **kw] &&= 1; nil})
-    assert_equal([[0], {}, nil, [0, 1], {}, nil], h.v{h[0, *a, **kw] &&= 1; nil})
-    assert_equal([[], {kw: 5}, nil, [1], {kw: 5}, nil], h.v{h[kw: 5] &&= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil, [1], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] &&= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil, [1], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] &&= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, nil, [0, 1], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] &&= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil, [0, 1], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] &&= 1; nil})
+    assert_syntax_error(%q{h[**kw] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] &&= 1; nil}, message)
 
     # &&=, with block, popped
-    assert_equal([[], {}, b, [1], {}, b], h.v{h[**kw, &b] &&= 1; nil})
-    assert_equal([[0], {}, b, [0, 1], {}, b], h.v{h[0, **kw, &b] &&= 1; nil})
-    assert_equal([[0], {}, b, [0, 1], {}, b], h.v{h[0, *a, **kw, &b] &&= 1; nil})
-    assert_equal([[], {kw: 5}, b, [1], {kw: 5}, b], h.v{h[kw: 5, &b] &&= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b, [1], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] &&= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b, [1], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] &&= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, b, [0, 1], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] &&= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b, [0, 1], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] &&= 1; nil})
+    assert_syntax_error(%q{h[**kw, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] &&= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] &&= 1; nil}, message)
 
     # ||=, without block, non-popped
-    assert_equal([[], {}, nil], h.v{h[**kw] ||= 1})
-    assert_equal([[0], {}, nil], h.v{h[0, **kw] ||= 1})
-    assert_equal([[0], {}, nil], h.v{h[0, *a, **kw] ||= 1})
-    assert_equal([[], {kw: 5}, nil], h.v{h[kw: 5] ||= 1})
-    assert_equal([[], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] ||= 1})
-    assert_equal([[], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] ||= 1})
-    assert_equal([[0], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] ||= 1})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] ||= 1})
+    assert_syntax_error(%q{h[**kw] ||= 1}, message)
+    assert_syntax_error(%q{h[0, **kw] ||= 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] ||= 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] ||= 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] ||= 1}, message)
 
     # ||=, with block, non-popped
-    assert_equal([[], {}, b], h.v{h[**kw, &b] ||= 1})
-    assert_equal([[0], {}, b], h.v{h[0, **kw, &b] ||= 1})
-    assert_equal([[0], {}, b], h.v{h[0, *a, **kw, &b] ||= 1})
-    assert_equal([[], {kw: 5}, b], h.v{h[kw: 5, &b] ||= 1})
-    assert_equal([[], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] ||= 1})
-    assert_equal([[], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] ||= 1})
-    assert_equal([[0], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] ||= 1})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] ||= 1})
+    assert_syntax_error(%q{h[**kw, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] ||= 1}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] ||= 1}, message)
 
     # ||=, without block, popped
-    assert_equal([[], {}, nil], h.v{h[**kw] ||= 1; nil})
-    assert_equal([[0], {}, nil], h.v{h[0, **kw] ||= 1; nil})
-    assert_equal([[0], {}, nil], h.v{h[0, *a, **kw] ||= 1; nil})
-    assert_equal([[], {kw: 5}, nil], h.v{h[kw: 5] ||= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] ||= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, nil], h.v{h[kw: 5, a: 2] ||= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, nil], h.v{h[0, kw: 5, a: 2] ||= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, nil: 3}, nil], h.v{h[0, *a, kw: 5, a: 2, nil: 3] ||= 1; nil})
+    assert_syntax_error(%q{h[**kw] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, nil: 3] ||= 1; nil}, message)
 
     # ||=, with block, popped
-    assert_equal([[], {}, b], h.v{h[**kw, &b] ||= 1; nil})
-    assert_equal([[0], {}, b], h.v{h[0, **kw, &b] ||= 1; nil})
-    assert_equal([[0], {}, b], h.v{h[0, *a, **kw, &b] ||= 1; nil})
-    assert_equal([[], {kw: 5}, b], h.v{h[kw: 5, &b] ||= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] ||= 1; nil})
-    assert_equal([[], {kw: 5, a: 2}, b], h.v{h[kw: 5, a: 2, &b] ||= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2}, b], h.v{h[0, kw: 5, a: 2, &b] ||= 1; nil})
-    assert_equal([[0], {kw: 5, a: 2, b: 3}, b], h.v{h[0, *a, kw: 5, a: 2, b: 3, &b] ||= 1; nil})
+    assert_syntax_error(%q{h[**kw, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, **kw, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, **kw, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[kw: 5, a: 2, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, kw: 5, a: 2, &b] ||= 1; nil}, message)
+    assert_syntax_error(%q{h[0, *a, kw: 5, a: 2, b: 3, &b] ||= 1; nil}, message)
 
   end
 
@@ -265,20 +267,12 @@ class TestCall < Test::Unit::TestCase
     def o.[](...) 2 end
     def o.[]=(...) end
 
-    o[kw: 1] += 1
-    assert_equal([], ary)
-
-    o[**o] += 1
-    assert_equal([:to_hash], ary)
-
-    ary.clear
-    o[**o, &o] += 1
-    # to_proc called twice because no VM instruction for coercing to proc
-    assert_equal([:to_hash, :to_proc, :to_proc], ary)
+    message = /keyword arg given in index/
 
-    ary.clear
-    o[*o, **o, &o] += 1
-    assert_equal([:to_a, :to_hash, :to_proc, :to_proc], ary)
+    assert_syntax_error(%q{o[kw: 1] += 1}, message)
+    assert_syntax_error(%q{o[**o] += 1}, message)
+    assert_syntax_error(%q{o[**o, &o] += 1}, message)
+    assert_syntax_error(%q{o[*o, **o, &o] += 1}, message)
   end
 
   def test_call_op_asgn_keywords_mutable
@@ -295,10 +289,12 @@ class TestCall < Test::Unit::TestCase
       def []=(*a, **b) @set = [a, b] end
     end.new
 
+    message = /keyword arg given in index/
+
     a = []
     kw = {}
 
-    assert_equal([[2], {b: 5}, [2, 4], {b: 5}], h.v{h[*a, 2, b: 5, **kw] += 1})
+    assert_syntax_error(%q{h[*a, 2, b: 5, **kw] += 1}, message)
   end
 
   def test_call_splat_order