An Masgn of 1

There's a weird case in Ruby that produces an masgn of a single argument,
and that behaves like an lasgn when called as a proc (Proc#call) and like an
masgn when called as a block (either blk.call or yield in a method).
Specifically, this happens with procs of the form {|x,| }

Let's take a look at the parse tree of {|x,| }:

[:iter, [:fcall, :proc], [:masgn, [:array, [:lasgn, :x]], nil, nil]]

Now, let's take a look at what happens when a proc of that form is called
with an Array:

({|x,| x}).call([1])
=> [1]

Next, let's take a look at what happens when a proc of that form is yielded
to in a method:

def foo
yield [1]
end

def bar(&blk)
blk.call([1])
end

foo {|x,| x}
=> 1
bar {|x,| x}
=> 1

It seems like this is happening because the |x,| syntax is getting errantly
parsed as an masgn, and treated as such as a block, but somehow treated as
an lasgn in the standlone lambda case. Am I misunderstanding something?

-- 
Yehuda Katz
Developer | Engine Yard
(ph) 718.877.1325