euler:rbx-cpp brian$ rm -f spec/parser/run.rbc; spec/parser/run.rb -r spec/parser
.........E.F.....F.F.FF......FF..F...F..........F.........................FFFFFF.....FFF.FFF...FFFFF....F.F.F...............F..FF............FF.................FFFFF.FFFFFFF......F.FFFFFF..F.FFFFFFF.F...FFF.........FF.F...F......FF..................F......F.F..F.......F................................F..F..
 
1)
spec/parser/attrasgn_index_equals_space_spec.rb
#<SyntaxError: syntax error, unexpected '=', expecting $end>
kernel/delta/string.rb:25:in `to_sexp_pt'
spec/parser/run.rb:6:in `to_sexp_pt_r'
spec/parser/run.rb:32:in `run'
spec/parser/run.rb:118
kernel/common/array.rb:572:in `each'
spec/parser/run.rb:102
kernel/common/compiled_method.rb:243:in `activate_as_script'
kernel/common/compiled_method.rb:236:in `as_script'
kernel/common/compile.rb:241:in `single_load'
kernel/common/compile.rb:319:in `load_from_extension'
kernel/loader.rb:202
 
2)
attrasgn
 
y = 0
42.method = y
 
 
expected
  [:block, [:lasgn, :y, [:fixnum, 0]], [:attrasgn, [:lit, 42], :method, [:array, [:lvar, :y]]]]
to equal
  [:block, [:lasgn, :y, [:lit, 0]], [:attrasgn, [:lit, 42], :method=, [:array, [:lvar, :y]]]]
 
 
3)
begin_rescue_twice
 
begin
  a
rescue => mes
  # do nothing
end
begin
  b
rescue => mes
  # do nothing
end
 
 
expected
  [:block, [:rescue, [:vcall, :a], [:resbody, nil, [:lasgn, :mes, [:gvar, :$!]]]], [:begin, [:rescue, [:vcall, :b], [:resbody, nil, [:lasgn, :mes, [:gvar, :$!]]]]]]
to equal
  [:block, [:begin, [:rescue, [:vcall, :a], [:resbody, nil, [:lasgn, :mes, [:gvar, :$!]]]]], [:begin, [:rescue, [:vcall, :b], [:resbody, nil, [:lasgn, :mes, [:gvar, :$!]]]]]]
 
 
4)
block_attrasgn
 
def self.setup(ctx)
  bind = allocate
  bind.context = ctx
  return bind
end
 
expected
  [:defs, [:self], :setup, [:scope, [:block, [:args, :ctx], [:lasgn, :bind, [:vcall, :allocate]], [:attrasgn, [:lvar, :bind], :context, [:array, [:lvar, :ctx]]], [:return, [:lvar, :bind]]]]]
to equal
  [:defs, [:self], :setup, [:scope, [:block, [:args, :ctx], [:lasgn, :bind, [:vcall, :allocate]], [:attrasgn, [:lvar, :bind], :context=, [:array, [:lvar, :ctx]]], [:return, [:lvar, :bind]]]]]
 
 
5)
block_mystery_block
 
a(b) do
  if b then
    true
  else
    c = false
    d { |x| c = true }
    c
  end
end
 
expected
  [:iter, [:fcall, :a, [:array, [:vcall, :b]]], nil, [:if, [:vcall, :b], [:true], [:block, [:lasgn, :c, [:false]], [:iter, [:fcall, :d], [:lasgn, :x], [:lasgn, :c, [:true]]], [:lvar, :c]]]]
to equal
  [:iter, [:fcall, :a, [:array, [:vcall, :b]]], nil, [:if, [:vcall, :b], [:true], [:block, [:dasgn_curr, :c, [:false]], [:iter, [:fcall, :d], [:dasgn_curr, :x], [:dasgn, :c, [:true]]], [:dvar, :c]]]]
 
 
6)
block_pass_args_and_splat
 
def blah(*args, &block)
  other(42, *args, &block)
end
 
expected
  [:defn, :blah, [:scope, [:block, [:args, :*], [:block_arg, :block], [:block_pass, [:lvar, :block], [:fcall, :other, [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]]
to equal
  [:defn, :blah, [:scope, [:block, [:args, :"*args"], [:block_arg, :block], [:block_pass, [:lvar, :block], [:fcall, :other, [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]]
 
 
7)
block_pass_omgwtf
 
define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })
 
expected
  [:block_pass, [:iter, [:call, [:const, :Proc], :new], [:masgn, [:lasgn, :args]], [:nil]], [:fcall, :define_attr_method, [:array, [:lit, :x], [:lit, :sequence_name]]]]
to equal
  [:block_pass, [:iter, [:call, [:const, :Proc], :new], [:masgn, nil, [:dasgn_curr, :args], nil], [:nil]], [:fcall, :define_attr_method, [:array, [:lit, :x], [:lit, :sequence_name]]]]
 
 
8)
block_pass_splat
 
def blah(*args, &block)
  other(*args, &block)
end
 
expected
  [:defn, :blah, [:scope, [:block, [:args, :*], [:block_arg, :block], [:block_pass, [:lvar, :block], [:fcall, :other, [:splat, [:lvar, :args]]]]]]]
to equal
  [:defn, :blah, [:scope, [:block, [:args, :"*args"], [:block_arg, :block], [:block_pass, [:lvar, :block], [:fcall, :other, [:splat, [:lvar, :args]]]]]]]
 
 
9)
block_stmt_after
 
def f
  begin
    b
  rescue
    c
  end
 
  d
end
 
expected
  [:defn, :f, [:scope, [:block, [:args], [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]], [:vcall, :d]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args], [:begin, [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]]], [:vcall, :d]]]]
 
 
10)
block_stmt_both
 
def f
  a
  begin
    b
  rescue
    c
  end
  d
end
 
expected
  [:defn, :f, [:scope, [:block, [:args], [:vcall, :a], [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]], [:vcall, :d]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args], [:vcall, :a], [:begin, [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]]], [:vcall, :d]]]]
 
 
11)
call_index_space
 
a = []
a [42]
 
 
expected
  [:block, [:lasgn, :a, [:zarray]], [:fcall, :a, [:array, [:array, [:lit, 42]]]]]
to equal
  [:block, [:lasgn, :a, [:zarray]], [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]]
 
 
12)
dasgn_0
 
a.each { |x| b.each { |y| x = (x + 1) } if true }
 
expected
  [:iter, [:call, [:vcall, :a], :each], [:lasgn, :x], [:if, [:true], [:iter, [:call, [:vcall, :b], :each], [:lasgn, :y], [:lasgn, :x, [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]], nil]]
to equal
  [:iter, [:call, [:vcall, :a], :each], [:dasgn_curr, :x], [:if, [:true], [:iter, [:call, [:vcall, :b], :each], [:dasgn_curr, :y], [:dasgn, :x, [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]], nil]]
 
 
13)
dasgn_1
 
a.each { |x| b.each { |y| c = (c + 1) } if true }
 
expected
  [:iter, [:call, [:vcall, :a], :each], [:lasgn, :x], [:if, [:true], [:iter, [:call, [:vcall, :b], :each], [:lasgn, :y], [:lasgn, :c, [:call, [:lvar, :c], :+, [:array, [:lit, 1]]]]], nil]]
to equal
  [:iter, [:call, [:vcall, :a], :each], [:dasgn_curr, :x], [:if, [:true], [:iter, [:call, [:vcall, :b], :each], [:dasgn_curr, :y], [:dasgn_curr, :c, [:call, [:dvar, :c], :+, [:array, [:lit, 1]]]]], nil]]
 
 
14)
dasgn_2
 
a.each do |x|
  if true then
    c = 0
    b.each { |y| c = (c + 1) }
  end
end
 
expected
  [:iter, [:call, [:vcall, :a], :each], [:lasgn, :x], [:if, [:true], [:block, [:lasgn, :c, [:fixnum, 0]], [:iter, [:call, [:vcall, :b], :each], [:lasgn, :y], [:lasgn, :c, [:call, [:lvar, :c], :+, [:array, [:lit, 1]]]]]], nil]]
to equal
  [:iter, [:call, [:vcall, :a], :each], [:dasgn_curr, :x], [:if, [:true], [:block, [:dasgn_curr, :c, [:lit, 0]], [:iter, [:call, [:vcall, :b], :each], [:dasgn_curr, :y], [:dasgn, :c, [:call, [:dvar, :c], :+, [:array, [:lit, 1]]]]]], nil]]
 
 
15)
dasgn_curr
 
data.each do |x, y|
  a = 1
  b = a
  b = a = x
end
 
expected
  [:iter, [:call, [:vcall, :data], :each], [:masgn, [:array, [:lasgn, :x], [:lasgn, :y]]], [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lvar, :a]], [:lasgn, :b, [:lasgn, :a, [:lvar, :x]]]]]
to equal
  [:iter, [:call, [:vcall, :data], :each], [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]], nil, nil], [:block, [:dasgn_curr, :a, [:lit, 1]], [:dasgn_curr, :b, [:dvar, :a]], [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]]
 
 
16)
dasgn_icky
 
a do
  v = nil
  assert_block(full_message) do
    begin
      yield
    rescue Exception => v
      break
    end
  end
end
 
expected
  [:iter, [:fcall, :a], nil, [:block, [:lasgn, :v, [:nil]], [:iter, [:fcall, :assert_block, [:array, [:vcall, :full_message]]], nil, [:begin, [:rescue, [:yield], [:resbody, [:array, [:const, :Exception]], [:block, [:lasgn, :v, [:gvar, :$!]], [:break]]]]]]]]
to equal
  [:iter, [:fcall, :a], nil, [:block, [:dasgn_curr, :v, [:nil]], [:iter, [:fcall, :assert_block, [:array, [:vcall, :full_message]]], nil, [:begin, [:rescue, [:yield], [:resbody, [:array, [:const, :Exception]], [:block, [:dasgn, :v, [:gvar, :$!]], [:break]]]]]]]]
 
 
17)
dasgn_mixed
 
t = 0
ns.each { |n| t += n }
 
 
expected
  [:block, [:lasgn, :t, [:fixnum, 0]], [:iter, [:call, [:vcall, :ns], :each], [:lasgn, :n], [:lasgn, :t, [:call, [:lvar, :t], :+, [:array, [:lvar, :n]]]]]]
to equal
  [:block, [:lasgn, :t, [:lit, 0]], [:iter, [:call, [:vcall, :ns], :each], [:dasgn_curr, :n], [:lasgn, :t, [:call, [:lvar, :t], :+, [:array, [:dvar, :n]]]]]]
 
 
18)
defn_args_mand_opt_splat_block
 
def f(mand, opt = 42, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :mand, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:block_arg, :block], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:block_arg, :block], [:nil]]]]
 
 
19)
defn_args_mand_opt_splat_no_name
 
def x(a, b = 42, *)
  # do nothing
end
 
expected
  [:defn, :x, [:scope, [:block, [:args, :a, :b, [:block, [:lasgn, :b, [:lit, 42]]]], [:nil]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :a, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]], [:nil]]]]
 
 
20)
defn_args_mand_opt_splat
 
def f(mand, opt = 42, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :mand, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:nil]]]]
 
 
21)
defn_args_mand_splat_block
 
def f(mand, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :mand, :*], [:block_arg, :block], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :mand, :"*rest"], [:block_arg, :block], [:nil]]]]
 
 
22)
defn_args_mand_splat_no_name
 
def x(a, *args)
  p(a, args)
end
 
expected
  [:defn, :x, [:scope, [:block, [:args, :a, :*], [:fcall, :p, [:array, [:lvar, :a], [:lvar, :args]]]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :a, :"*args"], [:fcall, :p, [:array, [:lvar, :a], [:lvar, :args]]]]]]
 
 
23)
defn_args_mand_splat
 
def f(mand, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :mand, :*], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :mand, :"*rest"], [:nil]]]]
 
 
24)
defn_args_opt_splat_block
 
def f(opt = 42, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:block_arg, :block], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:block_arg, :block], [:nil]]]]
 
 
25)
defn_args_opt_splat_no_name
 
def x(b = 42, *)
  # do nothing
end
 
expected
  [:defn, :x, [:scope, [:block, [:args, :b, [:block, [:lasgn, :b, [:lit, 42]]]], [:nil]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]], [:nil]]]]
 
 
26)
defn_args_opt_splat
 
def f(opt = 42, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:nil]]]]
 
 
27)
defn_args_splat_no_name
 
def x(*)
  # do nothing
end
 
expected
  [:defn, :x, [:scope, [:block, [:args], [:nil]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :*], [:nil]]]]
 
 
28)
defn_args_splat
 
def f(*rest)
  # do nothing
end
 
expected
  [:defn, :f, [:scope, [:block, [:args, :*], [:nil]]]]
to equal
  [:defn, :f, [:scope, [:block, [:args, :"*rest"], [:nil]]]]
 
 
29)
defn_splat_no_name
 
def x(a, *)
  p(a)
end
 
expected
  [:defn, :x, [:scope, [:block, [:args, :a], [:fcall, :p, [:array, [:lvar, :a]]]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :a, :*], [:fcall, :p, [:array, [:lvar, :a]]]]]]
 
 
30)
defs_empty_args
 
def self.empty(*)
  # do nothing
end
 
expected
  [:defs, [:self], :empty, [:scope, [:args]]]
to equal
  [:defs, [:self], :empty, [:scope, [:args, :*]]]
 
 
31)
defs_expr_wtf
 
def (a.b).empty(*)
  # do nothing
end
 
expected
  [:defs, [:call, [:vcall, :a], :b], :empty, [:scope, [:args]]]
to equal
  [:defs, [:call, [:vcall, :a], :b], :empty, [:scope, [:args, :*]]]
 
 
32)
dstr_heredoc_yet_again
 
<<-EOF
s1 '#{RUBY_PLATFORM}' s2
#{__FILE__}
        EOF
 
 
expected
  [:dstr, "s1 '", [:evstr, [:const, :RUBY_PLATFORM]], [:str, "' s2\n"], [:evstr, [:file]], [:str, "\n"]]
to equal
  [:dstr, "s1 '", [:evstr, [:const, :RUBY_PLATFORM]], [:str, "' s2\n"], [:str, "(string)"], [:str, "\n"]]
 
 
33)
dstr_str_lit_start
 
"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"
 
expected
  [:dstr, "blah", [:evstr, [:file]], [:str, ":"], [:evstr, [:fixnum, 1]], [:str, ": warning: "], [:evstr, [:call, [:gvar, :$!], :message]], [:str, " ("], [:evstr, [:call, [:gvar, :$!], :class]], [:str, ")"]]
to equal
  [:dstr, "blah(string):", [:evstr, [:lit, 1]], [:str, ": warning: "], [:evstr, [:call, [:gvar, :$!], :message]], [:str, " ("], [:evstr, [:call, [:gvar, :$!], :class]], [:str, ")"]]
 
 
34)
dstr_the_revenge
 
"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"
 
expected
  [:dstr, "before ", [:evstr, [:vcall, :from]], [:str, " middle "], [:evstr, [:vcall, :to]], [:str, " ("], [:evstr, [:file]], [:str, ":"], [:evstr, [:fixnum, 1]], [:str, ")"]]
to equal
  [:dstr, "before ", [:evstr, [:vcall, :from]], [:str, " middle "], [:evstr, [:vcall, :to]], [:str, " ("], [:str, "(string)"], [:str, ":"], [:evstr, [:lit, 1]], [:str, ")"]]
 
 
35)
flip2
 
x = if ((i % 4) == 0)..((i % 3) == 0) then
  i
else
  nil
end
 
expected
  [:lasgn, :x, [:if, [:flip2, [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 4]]], :==, [:array, [:fixnum, 0]]], [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 3]]], :==, [:array, [:fixnum, 0]]]], [:vcall, :i], [:nil]]]
to equal
  [:lasgn, :x, [:if, [:flip2, [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 4]]], :==, [:array, [:lit, 0]]], [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 3]]], :==, [:array, [:lit, 0]]]], [:vcall, :i], [:nil]]]
 
 
36)
flip3
 
x = if ((i % 4) == 0)...((i % 3) == 0) then
  i
else
  nil
end
 
expected
  [:lasgn, :x, [:if, [:flip3, [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 4]]], :==, [:array, [:fixnum, 0]]], [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 3]]], :==, [:array, [:fixnum, 0]]]], [:vcall, :i], [:nil]]]
to equal
  [:lasgn, :x, [:if, [:flip3, [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 4]]], :==, [:array, [:lit, 0]]], [:call, [:call, [:vcall, :i], :%, [:array, [:lit, 3]]], :==, [:array, [:lit, 0]]]], [:vcall, :i], [:nil]]]
 
 
37)
iter_call_arglist_space
 
a (1) {|c|d}
 
expected
  [:iter, [:fcall, :a, [:array, [:lit, 1]]], [:lasgn, :c], [:vcall, :d]]
to equal
  [:iter, [:fcall, :a, [:array, [:lit, 1]]], [:dasgn_curr, :c], [:vcall, :d]]
 
 
38)
iter_dasgn_curr_dasgn_madness
 
as.each { |a|
  b += a.b(false) }
 
expected
  [:iter, [:call, [:vcall, :as], :each], [:lasgn, :a], [:lasgn, :b, [:call, [:lvar, :b], :+, [:array, [:call, [:lvar, :a], :b, [:array, [:false]]]]]]]
to equal
  [:iter, [:call, [:vcall, :as], :each], [:dasgn_curr, :a], [:dasgn_curr, :b, [:call, [:dvar, :b], :+, [:array, [:call, [:dvar, :a], :b, [:array, [:false]]]]]]]
 
 
39)
iter_downto
 
3.downto(1) { |n| puts(n.to_s) }
 
expected
  [:iter, [:call, [:lit, 3], :downto, [:array, [:lit, 1]]], [:lasgn, :n], [:fcall, :puts, [:array, [:call, [:lvar, :n], :to_s]]]]
to equal
  [:iter, [:call, [:lit, 3], :downto, [:array, [:lit, 1]]], [:dasgn_curr, :n], [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]]
 
 
40)
iter_each_lvar
 
array = [1, 2, 3]
array.each { |x| puts(x.to_s) }
 
 
expected
  [:block, [:lasgn, :array, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]], [:iter, [:call, [:lvar, :array], :each], [:lasgn, :x], [:fcall, :puts, [:array, [:call, [:lvar, :x], :to_s]]]]]
to equal
  [:block, [:lasgn, :array, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]], [:iter, [:call, [:lvar, :array], :each], [:dasgn_curr, :x], [:fcall, :puts, [:array, [:call, [:dvar, :x], :to_s]]]]]
 
 
41)
iter_each_nested
 
array1 = [1, 2, 3]
array2 = [4, 5, 6, 7]
array1.each do |x|
  array2.each do |y|
    puts(x.to_s)
    puts(y.to_s)
  end
end
 
 
expected
  [:block, [:lasgn, :array1, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]], [:lasgn, :array2, [:array, [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]], [:iter, [:call, [:lvar, :array1], :each], [:lasgn, :x], [:iter, [:call, [:lvar, :array2], :each], [:lasgn, :y], [:block, [:fcall, :puts, [:array, [:call, [:lvar, :x], :to_s]]], [:fcall, :puts, [:array, [:call, [:lvar, :y], :to_s]]]]]]]
to equal
  [:block, [:lasgn, :array1, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]], [:lasgn, :array2, [:array, [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]], [:iter, [:call, [:lvar, :array1], :each], [:dasgn_curr, :x], [:iter, [:call, [:lvar, :array2], :each], [:dasgn_curr, :y], [:block, [:fcall, :puts, [:array, [:call, [:dvar, :x], :to_s]]], [:fcall, :puts, [:array, [:call, [:dvar, :y], :to_s]]]]]]]
 
 
42)
iter_masgn_2
 
a { |b, c| p(c) }
 
expected
  [:iter, [:fcall, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]], [:fcall, :p, [:array, [:lvar, :c]]]]
to equal
  [:iter, [:fcall, :a], [:masgn, [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]], nil, nil], [:fcall, :p, [:array, [:dvar, :c]]]]
 
 
43)
iter_masgn_args_splat_no_name
 
a { |b, c, *| p(c) }
 
expected
  [:iter, [:fcall, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:splat]], [:fcall, :p, [:array, [:lvar, :c]]]]
to equal
  [:iter, [:fcall, :a], [:masgn, [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]], [:splat], nil], [:fcall, :p, [:array, [:dvar, :c]]]]
 
 
44)
iter_masgn_args_splat
 
a { |b, c, *d| p(c) }
 
expected
  [:iter, [:fcall, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lasgn, :d]], [:fcall, :p, [:array, [:lvar, :c]]]]
to equal
  [:iter, [:fcall, :a], [:masgn, [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]], [:dasgn_curr, :d], nil], [:fcall, :p, [:array, [:dvar, :c]]]]
 
 
45)
iter_masgn_splat_no_name
 
a { |*| p(c) }
 
expected
  [:iter, [:fcall, :a], [:masgn, [:splat]], [:fcall, :p, [:array, [:vcall, :c]]]]
to equal
  [:iter, [:fcall, :a], [:masgn, nil, [:splat], nil], [:fcall, :p, [:array, [:vcall, :c]]]]
 
 
46)
iter_masgn_splat
 
a { |*c| p(c) }
 
expected
  [:iter, [:fcall, :a], [:masgn, [:lasgn, :c]], [:fcall, :p, [:array, [:lvar, :c]]]]
to equal
  [:iter, [:fcall, :a], [:masgn, nil, [:dasgn_curr, :c], nil], [:fcall, :p, [:array, [:dvar, :c]]]]
 
 
47)
iter_shadowed_var
 
a do |x|
  b do |x|
    puts x
  end
end
 
expected
  [:iter, [:fcall, :a], [:lasgn, :x], [:iter, [:fcall, :b], [:lasgn, :x], [:fcall, :puts, [:array, [:lvar, :x]]]]]
to equal
  [:iter, [:fcall, :a], [:dasgn_curr, :x], [:iter, [:fcall, :b], [:dasgn, :x], [:fcall, :puts, [:array, [:dvar, :x]]]]]
 
 
48)
iter_upto
 
1.upto(3) { |n| puts(n.to_s) }
 
expected
  [:iter, [:call, [:lit, 1], :upto, [:array, [:lit, 3]]], [:lasgn, :n], [:fcall, :puts, [:array, [:call, [:lvar, :n], :to_s]]]]
to equal
  [:iter, [:call, [:lit, 1], :upto, [:array, [:lit, 3]]], [:dasgn_curr, :n], [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]]
 
 
49)
lit_long_negative
 
-1
 
expected
  [:negate, [:lit, 1]]
to equal
  [:lit, -1]
 
 
50)
lit_range2
 
(1..10)
 
expected
  [:dot2, [:lit, 1], [:lit, 10]]
to equal
  [:lit, 1..10]
 
 
51)
lit_range3
 
(1...10)
 
expected
  [:dot3, [:lit, 1], [:lit, 10]]
to equal
  [:lit, 1...10]
 
 
52)
lit_regexp_i_wwtt
 
str.split(//i)
 
expected
  [:call, [:vcall, :str], :split, [:array, [:regex, "", 1]]]
to equal
  [:call, [:vcall, :str], :split, [:array, [:lit, //i]]]
 
 
53)
lit_regexp_n
 
/x/n
 
expected
  [:regex, "x", 16]
to equal
  [:lit, /x/]
 
 
54)
lit_regexp_once
 
/x/o
 
expected
  [:regex, "x", 0]
to equal
  [:lit, /x/]
 
 
55)
lit_regexp
 
/x/
 
expected
  [:regex, "x", 0]
to equal
  [:lit, /x/]
 
 
56)
lvar_def_boundary
 
b = 42
def a
  c do
    begin
      do_stuff
    rescue RuntimeError => b
      puts(b)
    end
  end
end
 
 
expected
  [:block, [:lasgn, :b, [:lit, 42]], [:defn, :a, [:scope, [:block, [:args], [:iter, [:fcall, :c], nil, [:begin, [:rescue, [:vcall, :do_stuff], [:resbody, [:array, [:const, :RuntimeError]], [:block, [:lasgn, :b, [:gvar, :$!]], [:fcall, :puts, [:array, [:lvar, :b]]]]]]]]]]]]
to equal
  [:block, [:lasgn, :b, [:lit, 42]], [:defn, :a, [:scope, [:block, [:args], [:iter, [:fcall, :c], nil, [:begin, [:rescue, [:vcall, :do_stuff], [:resbody, [:array, [:const, :RuntimeError]], [:block, [:dasgn_curr, :b, [:gvar, :$!]], [:fcall, :puts, [:array, [:dvar, :b]]]]]]]]]]]]
 
 
57)
masgn_attrasgn_array_rhs
 
a.b, a.c, _ = q
 
expected
  [:masgn, [:array, [:attrasgn, [:vcall, :a], :b], [:attrasgn, [:vcall, :a], :c], [:lasgn, :_]], [:to_ary, [:vcall, :q]]]
to equal
  [:masgn, [:array, [:attrasgn, [:vcall, :a], :b=], [:attrasgn, [:vcall, :a], :c=], [:lasgn, :_]], nil, [:to_ary, [:vcall, :q]]]
 
 
58)
masgn_attrasgn_idx
 
a, i, j = [], 1, 2
a[i], a[j] = a[j], a[i]
 
 
expected
  [:block, [:masgn, [:array, [:lasgn, :a], [:lasgn, :i], [:lasgn, :j]], [:array, [:zarray], [:lit, 1], [:lit, 2]]], [:masgn, [:array, [:attrasgn, [:lvar, :a], :[]=, [:array, [:lvar, :i]]], [:attrasgn, [:lvar, :a], :[]=, [:array, [:lvar, :j]]]], [:array, [:call, [:lvar, :a], :[], [:array, [:lvar, :j]]], [:call, [:lvar, :a], :[], [:array, [:lvar, :i]]]]]]
to equal
  [:block, [:masgn, [:array, [:lasgn, :a], [:lasgn, :i], [:lasgn, :j]], nil, [:array, [:zarray], [:lit, 1], [:lit, 2]]], [:masgn, [:array, [:attrasgn, [:lvar, :a], :[]=, [:array, [:lvar, :i]]], [:attrasgn, [:lvar, :a], :[]=, [:array, [:lvar, :j]]]], nil, [:array, [:call, [:lvar, :a], :[], [:array, [:lvar, :j]]], [:call, [:lvar, :a], :[], [:array, [:lvar, :i]]]]]]
 
 
59)
masgn_attrasgn
 
a, b.c = d, e
 
expected
  [:masgn, [:array, [:lasgn, :a], [:attrasgn, [:vcall, :b], :c]], [:array, [:vcall, :d], [:vcall, :e]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:attrasgn, [:vcall, :b], :c=]], nil, [:array, [:vcall, :d], [:vcall, :e]]]
 
 
60)
masgn_cdecl
 
A, B, C = 1, 2, 3
 
expected
  [:masgn, [:array, [:cdecl, :A], [:cdecl, :B], [:cdecl, :C]], [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
to equal
  [:masgn, [:array, [:cdecl, :A], [:cdecl, :B], [:cdecl, :C]], nil, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
 
 
61)
masgn_iasgn
 
a, @b = c, d
 
expected
  [:masgn, [:array, [:lasgn, :a], [:iasgn, :@b]], [:array, [:vcall, :c], [:vcall, :d]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:iasgn, :@b]], nil, [:array, [:vcall, :c], [:vcall, :d]]]
 
 
62)
masgn_masgn
 
a, (b, c) = [1, [2, 3]]
 
expected
  [:masgn, [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]], [:to_ary, [:array, [:lit, 1], [:array, [:lit, 2], [:lit, 3]]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], nil, nil]], nil, [:to_ary, [:array, [:lit, 1], [:array, [:lit, 2], [:lit, 3]]]]]
 
 
63)
masgn
 
a, b = c, d
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:array, [:vcall, :c], [:vcall, :d]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], nil, [:array, [:vcall, :c], [:vcall, :d]]]
 
 
64)
masgn_splat_no_name_trailing
 
a, b, = c
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:to_ary, [:vcall, :c]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], nil, [:to_ary, [:vcall, :c]]]
 
 
65)
match2
 
/x/ =~ "blah"
 
expected
  [:match2, [:regex, "x", 0], [:str, "blah"]]
to equal
  [:match2, [:lit, /x/], [:str, "blah"]]
 
 
66)
match3
 
"blah" =~ /x/
 
expected
  [:match3, [:regex, "x", 0], [:str, "blah"]]
to equal
  [:match3, [:lit, /x/], [:str, "blah"]]
 
 
67)
match
 
1 if /x/
 
expected
  [:if, [:match, "x", 0], [:lit, 1], nil]
to equal
  [:if, [:match, [:lit, /x/]], [:lit, 1], nil]
 
 
68)
op_asgn2_self
 
self.Bag ||= Bag.new
 
expected
  [:op_asgn2, [:self], :Bag, :"||", [:call, [:const, :Bag], :new]]
to equal
  [:op_asgn2, [:self], :Bag=, :"||", [:call, [:const, :Bag], :new]]
 
 
69)
op_asgn2
 
s = Struct.new(:var)
c = s.new(nil)
c.var ||= 20
c.var &&= 21
c.var += 22
c.d.e.f ||= 42
 
 
expected
  [:block, [:lasgn, :s, [:call, [:const, :Struct], :new, [:array, [:lit, :var]]]], [:lasgn, :c, [:call, [:lvar, :s], :new, [:array, [:nil]]]], [:op_asgn2, [:lvar, :c], :var, :"||", [:lit, 20]], [:op_asgn2, [:lvar, :c], :var, :"&&", [:lit, 21]], [:op_asgn2, [:lvar, :c], :var, :+, [:lit, 22]], [:op_asgn2, [:call, [:call, [:lvar, :c], :d], :e], :f, :"||", [:lit, 42]]]
to equal
  [:block, [:lasgn, :s, [:call, [:const, :Struct], :new, [:array, [:lit, :var]]]], [:lasgn, :c, [:call, [:lvar, :s], :new, [:array, [:nil]]]], [:op_asgn2, [:lvar, :c], :var=, :"||", [:lit, 20]], [:op_asgn2, [:lvar, :c], :var=, :"&&", [:lit, 21]], [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]], [:op_asgn2, [:call, [:call, [:lvar, :c], :d], :e], :f=, :"||", [:lit, 42]]]
 
 
70)
op_asgn_and
 
a = 0
a &&= 2
 
 
expected
  [:block, [:lasgn, :a, [:fixnum, 0]], [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]]
to equal
  [:block, [:lasgn, :a, [:lit, 0]], [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]]
 
 
71)
op_asgn_or
 
a = 0
a ||= 1
 
 
expected
  [:block, [:lasgn, :a, [:fixnum, 0]], [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]]
to equal
  [:block, [:lasgn, :a, [:lit, 0]], [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]]
 
 
72)
proc_args_1
 
proc { |x| (x + 1) }
 
expected
  [:iter, [:fcall, :proc], [:lasgn, :x], [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]
to equal
  [:iter, [:fcall, :proc], [:dasgn_curr, :x], [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]
 
 
73)
proc_args_2
 
proc { |x, y| (x + y) }
 
expected
  [:iter, [:fcall, :proc], [:masgn, [:array, [:lasgn, :x], [:lasgn, :y]]], [:call, [:lvar, :x], :+, [:array, [:lvar, :y]]]]
to equal
  [:iter, [:fcall, :proc], [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]], nil, nil], [:call, [:dvar, :x], :+, [:array, [:dvar, :y]]]]
 
 
74)
splat
 
def x(*b)
  a(*b)
end
 
expected
  [:defn, :x, [:scope, [:block, [:args, :*], [:fcall, :a, [:splat, [:lvar, :b]]]]]]
to equal
  [:defn, :x, [:scope, [:block, [:args, :"*b"], [:fcall, :a, [:splat, [:lvar, :b]]]]]]
 
 
75)
str_interp_file
 
"file = #{__FILE__}\n"
 
expected
  [:dstr, "file = ", [:evstr, [:file]], [:str, "\n"]]
to equal
  [:str, "file = (string)\n"]
 
 
76)
structure_extra_block_for_dvar_scoping
 
a.b do |c, d|
  unless e.f(c) then
    g = false
    d.h { |x, i| g = true }
  end
end
 
expected
  [:iter, [:call, [:vcall, :a], :b], [:masgn, [:array, [:lasgn, :c], [:lasgn, :d]]], [:if, [:call, [:vcall, :e], :f, [:array, [:lvar, :c]]], nil, [:block, [:lasgn, :g, [:false]], [:iter, [:call, [:lvar, :d], :h], [:masgn, [:array, [:lasgn, :x], [:lasgn, :i]]], [:lasgn, :g, [:true]]]]]]
to equal
  [:iter, [:call, [:vcall, :a], :b], [:masgn, [:array, [:dasgn_curr, :c], [:dasgn_curr, :d]], nil, nil], [:if, [:call, [:vcall, :e], :f, [:array, [:dvar, :c]]], nil, [:block, [:dasgn_curr, :g, [:false]], [:iter, [:call, [:dvar, :d], :h], [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :i]], nil, nil], [:dasgn, :g, [:true]]]]]]
 
 
77)
structure_unused_literal_wwtt
 
"prevent the above from infecting rdoc"
 
module Graffle
end
 
expected
  [:block, [:str, "prevent the above from infecting rdoc"], [:module, :Graffle, [:scope]]]
to equal
  [:module, :Graffle, [:scope]]
 
 
78)
to_ary
 
a, b = c
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:to_ary, [:vcall, :c]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], nil, [:to_ary, [:vcall, :c]]]
 
 
79)
yield_array
 
yield([42, 24])
 
expected
  [:yield, [:array, [:lit, 42], [:lit, 24]]]
to equal
  [:yield, [:array, [:lit, 42], [:lit, 24]], true]
 
 
80)
yield_zarray
 
yield([])
 
expected
  [:yield, [:zarray]]
to equal
  [:yield, [:zarray], true]
 
 
Finished in 2.053395 seconds
 
308 examples, 79 failures, 1 errors