* 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: http://svn.ruby-lang.org/repos/ruby/trunk@4848 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 63 insertions, 72 deletions

diff --git a/ChangeLog b/ChangeLog
index 229fa780c..4d7077f50 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+Tue Oct 28 11:24:18 2003  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* parse.y (new_yield): remove magic argument rule; "yield [1,2]"
+	  should yield single array of two elements, not two values.
+	  [ruby-dev:21726]
+
 Mon Oct 27 19:19:55 2003  Nobuyoshi Nakada  <nobu@ruby-lang.org>
 
 	* eval.c (rb_longjmp): ignore reentering error while warning.
diff --git a/parse.y b/parse.y
index 3f738e2cd..7901bcab3 100644
--- a/parse.y
+++ b/parse.y
@@ -5377,22 +5377,7 @@ static NODE *
 new_yield(node)
     NODE *node;
 {
-    long state = Qtrue;
-
-    if (node) {
-	no_blockarg(node);
-	if (nd_type(node) == NODE_ARRAY && node->nd_next == 0) {
-	    node = node->nd_head;
-	    state = Qfalse;
-	}
-	if (nd_type(node) == NODE_SPLAT) {
-	    state = Qtrue;
-	}
-    }
-    else {
-	state = Qfalse;
-    }
-    return NEW_YIELD(node, state);
+    return NEW_YIELD(node, node ? Qtrue : Qfalse);
 }
 
 static NODE*
diff --git a/sample/test.rb b/sample/test.rb
index 6488558fd..02befbedc 100644
--- a/sample/test.rb
+++ b/sample/test.rb
@@ -151,13 +151,13 @@ def f; yield *[*[1,2]]; end; f {|*a| test_ok(a == [1,2])}
 def f; yield; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
 def f; yield nil; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
 def f; yield 1; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
-def f; yield []; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
-def f; yield [1]; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
-def f; yield [nil]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
-def f; yield [[]]; end; f {|a,b,*c| test_ok([a,b,c] == [[],nil,[]])}
-def f; yield [*[]]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
-def f; yield [*[1]]; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
-def f; yield [*[1,2]]; end; f {|a,b,*c| test_ok([a,b,c] == [1,2,[]])}
+def f; yield []; end; f {|a,b,*c| test_ok([a,b,c] == [[],nil,[]])}
+def f; yield [1]; end; f {|a,b,*c| test_ok([a,b,c] == [[1],nil,[]])}
+def f; yield [nil]; end; f {|a,b,*c| test_ok([a,b,c] == [[nil],nil,[]])}
+def f; yield [[]]; end; f {|a,b,*c| test_ok([a,b,c] == [[[]],nil,[]])}
+def f; yield [*[]]; end; f {|a,b,*c| test_ok([a,b,c] == [[],nil,[]])}
+def f; yield [*[1]]; end; f {|a,b,*c| test_ok([a,b,c] == [[1],nil,[]])}
+def f; yield [*[1,2]]; end; f {|a,b,*c| test_ok([a,b,c] == [[1,2],nil,[]])}
 
 def f; yield *nil; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
 def f; yield *1; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb
index 51d1c780f..e78021558 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 e21c464de..c20f67f57 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