* parse.y (new_yield): remove magic argument rule; "yield [1,2]"

  should yield single array of two elements, not two values.
  [ruby-dev:21726]


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4848 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

2 files changed, 49 insertions, 49 deletions

diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb
index 51d1c780f8..e78021558f 100644
--- a/test/ruby/test_assignment.rb
+++ b/test/ruby/test_assignment.rb
@@ -130,13 +130,13 @@ class TestAssignment < Test::Unit::TestCase
     def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
     def f; yield nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
     def f; yield 1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
-    def f; yield []; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
-    def f; yield [1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
-    def f; yield [nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
-    def f; yield [[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
-    def f; yield [*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
-    def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
-    def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
+    def f; yield []; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
+    def f; yield [1]; end; f {|a,b,*c| assert_equal([[1],nil,[]], [a,b,c])}
+    def f; yield [nil]; end; f {|a,b,*c| assert_equal([[nil],nil,[]], [a,b,c])}
+    def f; yield [[]]; end; f {|a,b,*c| assert_equal([[[]],nil,[]], [a,b,c])}
+    def f; yield [*[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
+    def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([[1],nil,[]], [a,b,c])}
+    def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([[1,2],nil,[]], [a,b,c])}
 
     def f; yield *nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
     def f; yield *1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb
index e21c464de3..c20f67f573 100644
--- a/test/ruby/test_hash.rb
+++ b/test/ruby/test_hash.rb
@@ -4,13 +4,13 @@ $KCODE = 'none'
 
 class TestHash < Test::Unit::TestCase
   def test_hash
-    $x = {1=>2, 2=>4, 3=>6}
-    $y = {1, 2, 2, 4, 3, 6}
+    x = {1=>2, 2=>4, 3=>6}
+    y = {1, 2, 2, 4, 3, 6}
 
-    assert_equal(2, $x[1])
+    assert_equal(2, x[1])
 
     assert(begin
-         for k,v in $y
+         for k,v in y
            raise if k*2 != v
          end
          true
@@ -18,59 +18,59 @@ class TestHash < Test::Unit::TestCase
          false
        end)
 
-    assert_equal(3, $x.length)
-    assert($x.has_key?(1))
-    assert($x.has_value?(4))
-    assert_equal([4,6], $x.values_at(2,3))
-    assert_equal({1=>2, 2=>4, 3=>6}, $x)
+    assert_equal(3, x.length)
+    assert(x.has_key?(1))
+    assert(x.has_value?(4))
+    assert_equal([4,6], x.values_at(2,3))
+    assert_equal({1=>2, 2=>4, 3=>6}, x)
 
-    $z = $y.keys.join(":")
-    assert_equal("1:2:3", $z)
+    z = y.keys.join(":")
+    assert_equal("1:2:3", z)
 
-    $z = $y.values.join(":")
-    assert_equal("2:4:6", $z)
-    assert_equal($x, $y)
+    z = y.values.join(":")
+    assert_equal("2:4:6", z)
+    assert_equal(x, y)
 
-    $y.shift
-    assert_equal(2, $y.length)
+    y.shift
+    assert_equal(2, y.length)
 
-    $z = [1,2]
-    $y[$z] = 256
-    assert_equal(256, $y[$z])
+    z = [1,2]
+    y[z] = 256
+    assert_equal(256, y[z])
 
-    $x = Hash.new(0)
-    $x[1] = 1
-    assert_equal(1, $x[1])
-    assert_equal(0, $x[2])
+    x = Hash.new(0)
+    x[1] = 1
+    assert_equal(1, x[1])
+    assert_equal(0, x[2])
 
-    $x = Hash.new([])
-    assert_equal([], $x[22])
-    assert_same($x[22], $x[22])
+    x = Hash.new([])
+    assert_equal([], x[22])
+    assert_same(x[22], x[22])
 
-    $x = Hash.new{[]}
-    assert_equal([], $x[22])
-    assert_not_same($x[22], $x[22])
+    x = Hash.new{[]}
+    assert_equal([], x[22])
+    assert_not_same(x[22], x[22])
 
-    $x = Hash.new{|h,k| $z = k; h[k] = k*2}
-    $z = 0
-    assert_equal(44, $x[22])
-    assert_equal(22, $z)
-    $z = 0
-    assert_equal(44, $x[22])
-    assert_equal(0, $z)
-    $x.default = 5
-    assert_equal(5, $x[23])
+    x = Hash.new{|h,k| z = k; h[k] = k*2}
+    z = 0
+    assert_equal(44, x[22])
+    assert_equal(22, z)
+    z = 0
+    assert_equal(44, x[22])
+    assert_equal(0, z)
+    x.default = 5
+    assert_equal(5, x[23])
 
-    $x = Hash.new
-    def $x.default(k)
+    x = Hash.new
+    def x.default(k)
       $z = k
       self[k] = k*2
     end
     $z = 0
-    assert_equal(44, $x[22])
+    assert_equal(44, x[22])
     assert_equal(22, $z)
     $z = 0
-    assert_equal(44, $x[22])
+    assert_equal(44, x[22])
     assert_equal(0, $z)
   end
 end