Fix assignment operators when argument is a splat operator

Author: andrykonchin

spec/ruby/language/assignments_spec.rb

@@ -34,6 +34,22 @@ def a=(n) @a = n; 42 end
     end
 
     describe 'using a #[]' do
+      before do
+        klass = Class.new do
+          def [](k)
+            @hash ||= {}
+            @hash[k]
+          end
+
+          def []=(k, v)
+            @hash ||= {}
+            @hash[k] = v
+            7
+          end
+        end
+        @b = klass.new
+      end
+
       it 'evaluates receiver only once when assigns' do
         ScratchPad.record []
         a = {k: 1}
@@ -56,6 +72,62 @@ def []=(k, v) @a[k] = v; 42 end
         a = klass_with_private_methods.new(k: 0)
         a.public_method(:k, 2).should == 2
       end
+
+      context 'splatted argument' do
+        it 'correctly handles it' do
+          @b[:m] = 10
+          (@b[*[:m]] += 10).should == 20
+          @b[:m].should == 20
+
+          @b[:n] = 10
+          (@b[*(1; [:n])] += 10).should == 20
+          @b[:n].should == 20
+
+          @b[:k] = 10
+          (@b[*begin 1; [:k] end] += 10).should == 20
+          @b[:k].should == 20
+        end
+
+        it 'calls #to_a only once' do
+          k = Object.new
+          def k.to_a
+            ScratchPad << :to_a
+            [:k]
+          end
+
+          ScratchPad.record []
+          @b[:k] = 10
+          (@b[*k] += 10).should == 20
+          @b[:k].should == 20
+          ScratchPad.recorded.should == [:to_a]
+        end
+
+        it 'correctly handles a nested splatted argument' do
+          @b[:k] = 10
+          (@b[*[*[:k]]] += 10).should == 20
+          @b[:k].should == 20
+        end
+
+        it 'correctly handles multiple nested splatted arguments' do
+          klass_with_multiple_parameters = Class.new do
+            def [](k1, k2, k3)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"]
+            end
+
+            def []=(k1, k2, k3, v)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"] = v
+              7
+            end
+          end
+          a = klass_with_multiple_parameters.new
+
+          a[:a, :b, :c] = 10
+          (a[*[:a], *[:b], *[:c]] += 10).should == 20
+          a[:a, :b, :c].should == 20
+        end
+      end
     end
 
     describe 'using compounded constants' do

spec/ruby/language/optional_assignments_spec.rb

@@ -168,10 +168,6 @@ def []=(k, v)
         (@b[:k] ||= 12).should == 12
       end
 
-      it 'correctly handles a splatted argument for the index' do
-        (@b[*[:k]] ||= 12).should == 12
-      end
-
       it "evaluates the index precisely once" do
         ary = [:x, :y]
         @a[:x] = 15
@@ -228,6 +224,56 @@ def []=(k, v) @a[k] = v; 42 end
         a = klass_with_private_methods.new(k: false)
         a.public_method(:k, 10).should == 10
       end
+
+      context 'splatted argument' do
+        it 'correctly handles it' do
+          (@b[*[:m]] ||= 10).should == 10
+          @b[:m].should == 10
+
+          (@b[*(1; [:n])] ||= 10).should == 10
+          @b[:n].should == 10
+
+          (@b[*begin 1; [:k] end] ||= 10).should == 10
+          @b[:k].should == 10
+        end
+
+        it 'calls #to_a only once' do
+          k = Object.new
+          def k.to_a
+            ScratchPad << :to_a
+            [:k]
+          end
+
+          ScratchPad.record []
+          (@b[*k] ||= 20).should == 20
+          @b[:k].should == 20
+          ScratchPad.recorded.should == [:to_a]
+        end
+
+        it 'correctly handles a nested splatted argument' do
+          (@b[*[*[:k]]] ||= 20).should == 20
+          @b[:k].should == 20
+        end
+
+        it 'correctly handles multiple nested splatted arguments' do
+          klass_with_multiple_parameters = Class.new do
+            def [](k1, k2, k3)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"]
+            end
+
+            def []=(k1, k2, k3, v)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"] = v
+              7
+            end
+          end
+          a = klass_with_multiple_parameters.new
+
+          (a[*[:a], *[:b], *[:c]] ||= 20).should == 20
+          a[:a, :b, :c].should == 20
+        end
+      end
     end
   end
 
@@ -407,12 +453,6 @@ def []=(k, v)
         (@b[:k] &&= 12).should == 12
       end
 
-      it 'correctly handles a splatted argument for the index' do
-        @b[:k] = 10
-        (@b[*[:k]] &&= 12).should == 12
-        @b[:k].should == 12
-      end
-
       it "evaluates the index precisely once" do
         ary = [:x, :y]
         @a[:x] = 15
@@ -475,6 +515,62 @@ def []=(k, v) @a[k] = v; 42 end
         a = klass_with_private_methods.new(k: true)
         a.public_method(:k, 10).should == 10
       end
+
+      context 'splatted argument' do
+        it 'correctly handles it' do
+          @b[:m] = 0
+          (@b[*[:m]] &&= 10).should == 10
+          @b[:m].should == 10
+
+          @b[:n] = 0
+          (@b[*(1; [:n])] &&= 10).should == 10
+          @b[:n].should == 10
+
+          @b[:k] = 0
+          (@b[*begin 1; [:k] end] &&= 10).should == 10
+          @b[:k].should == 10
+        end
+
+        it 'calls #to_a only once' do
+          k = Object.new
+          def k.to_a
+            ScratchPad << :to_a
+            [:k]
+          end
+
+          ScratchPad.record []
+          @b[:k] = 10
+          (@b[*k] &&= 20).should == 20
+          @b[:k].should == 20
+          ScratchPad.recorded.should == [:to_a]
+        end
+
+        it 'correctly handles a nested splatted argument' do
+          @b[:k] = 10
+          (@b[*[*[:k]]] &&= 20).should == 20
+          @b[:k].should == 20
+        end
+
+        it 'correctly handles multiple nested splatted arguments' do
+          klass_with_multiple_parameters = Class.new do
+            def [](k1, k2, k3)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"]
+            end
+
+            def []=(k1, k2, k3, v)
+              @hash ||= {}
+              @hash[:"#{k1}#{k2}#{k3}"] = v
+              7
+            end
+          end
+          a = klass_with_multiple_parameters.new
+
+          a[:a, :b, :c] = 10
+          (a[*[:a], *[:b], *[:c]] &&= 20).should == 20
+          a[:a, :b, :c].should == 20
+        end
+      end
     end
   end
 

spec/tags/language/assignments_tags.txt

@@ -1,3 +1,4 @@
 fails:Assignments using += using compounded constants causes side-effects of the module part to be applied only once (when assigns)
 fails:Assignments using += using an accessor ignores method visibility when receiver is self
 fails:Assignments using += using a #[] ignores method visibility when receiver is self
+fails:Assignments using += using a #[] splatted argument calls #to_a only once

spec/tags/language/optional_assignments_tags.txt

@@ -1,3 +1,5 @@
 fails:Optional constant assignment with &&= causes side-effects of the module part to be applied only once (when assigns)
 fails:Optional variable assignments using ||= using a #[] ignores method visibility when receiver is self
 fails:Optional variable assignments using &&= using a #[] ignores method visibility when receiver is self
+fails:Optional variable assignments using ||= using a #[] splatted argument calls #to_a only once
+fails:Optional variable assignments using &&= using a #[] splatted argument calls #to_a only once