euler:rbx-cpp brian$ rm -f spec/parser/run.rbc; spec/parser/run.rb spec/parser
...FFF...EFF..FFFFFF..FFFFFFFFFF..FF......F.....FF..........................F.FF.FFF.FFF.FFF.F.FFFFF....FFF.F...............F..FF..F...F.....FF........................FFFF........F.FFFFFF..FFFFF....F.FFFFFF.......FFFF.F...F..........FFFFFFFFF.......F......F....F.FFFFF...................................F.FF.
 
1)
argscat_inside
 
a = [b, *c]
 
expected
  [:lasgn, :a, [:argscat, [:array, [:call, nil, :b, [:arglist]]], [:call, nil, :c, [:arglist]]]]
to equal
  [:lasgn, :a, [:array, [:call, nil, :b, [:arglist]], [:splat, [:call, nil, :c, [:arglist]]]]]
 
 
2)
argscat_svalue
 
a = b, c, *d
 
expected
  [:lasgn, :a, [:svalue, [:argscat, [:array, [:call, nil, :b, [:arglist]], [:call, nil, :c, [:arglist]]], [:call, nil, :d, [:arglist]]]]]
to equal
  [:lasgn, :a, [:svalue, [:array, [:call, nil, :b, [:arglist]], [:call, nil, :c, [:arglist]], [:splat, [:call, nil, :d, [:arglist]]]]]]
 
 
3)
argspush
 
a[*b] = c
 
expected
  [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:argspush, [:splat, [:call, nil, :b, [:arglist]]], [:call, nil, :c, [:arglist]]]]
to equal
  [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:splat, [:call, nil, :b, [:arglist]]], [:call, nil, :c, [:arglist]]]]
 
 
4)
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:10:in `to_sexp_pt_u'
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
 
5)
attrasgn_index_equals
 
a[42] = 24
 
expected
  [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:array, [:lit, 42], [:lit, 24]]]
to equal
  [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:lit, 42], [:lit, 24]]]
 
 
6)
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=, [:arglist, [:lvar, :y]]]]
 
 
7)
begin_rescue_ensure_all_empty
 
begin
  # do nothing
rescue
  # do nothing
ensure
  # do nothing
end
 
expected
  [:begin, [:ensure, [:rescue, [:resbody, [:array], nil]], [:nil]]]
to equal
  [:ensure, [:rescue, [:resbody, [:array], nil]], [:nil]]
 
 
8)
begin_rescue_ensure
 
begin
  a
rescue
  # do nothing
ensure
  # do nothing
end
 
expected
  [:begin, [:ensure, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array], nil]], [:nil]]]
to equal
  [:ensure, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array], nil]], [:nil]]
 
 
9)
begin_rescue_twice_mri_verbose_flag
 
begin
  a
rescue => mes
  # do nothing
end
begin
  b
rescue => mes
  # do nothing
end
 
 
expected
  [:block, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]], [:begin, [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]]]]
to equal
  [:block, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]], [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]]]
 
 
10)
begin_rescue_twice
 
begin
  a
rescue => mes
  # do nothing
end
begin
  b
rescue => mes
  # do nothing
end
 
 
expected
  [:block, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]], [:begin, [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]]]]
to equal
  [:block, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]], [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array, [:lasgn, :mes, [:gvar, :$!]]], nil]]]
 
 
11)
begin
 
begin
  (1 + 1)
end
 
expected
  [:begin, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]]
to equal
  [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]
 
 
12)
block_attrasgn
 
def self.setup(ctx)
  bind = allocate
  bind.context = ctx
  return bind
end
 
expected
  [:defs, [:self], :setup, [:args, :ctx], [:scope, [:block, [:lasgn, :bind, [:call, nil, :allocate, [:arglist]]], [:attrasgn, [:lvar, :bind], :context, [:array, [:lvar, :ctx]]], [:return, [:lvar, :bind]]]]]
to equal
  [:defs, [:self], :setup, [:args, :ctx], [:scope, [:block, [:lasgn, :bind, [:call, nil, :allocate, [:arglist]]], [:attrasgn, [:lvar, :bind], :context=, [:arglist, [:lvar, :ctx]]], [:return, [:lvar, :bind]]]]]
 
 
13)
block_pass_args_and_splat
 
def blah(*args, &block)
  other(42, *args, &block)
end
 
expected
  [:defn, :blah, [:args, :*, [:block_arg, :block]], [:scope, [:block, [:block_pass, [:lvar, :block], [:call, nil, :other, [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]]
to equal
  [:defn, :blah, [:args, :"*args", :"&block"], [:scope, [:block, [:call, nil, :other, [:arglist, [:lit, 42], [:splat, [:lvar, :args]], [:block_pass, [:lvar, :block]]]]]]]
 
 
14)
block_pass_call_0
 
a.b(&c)
 
expected
  [:block_pass, [:call, nil, :c, [:arglist]], [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]]]
to equal
  [:call, [:call, nil, :a, [:arglist]], :b, [:arglist, [:block_pass, [:call, nil, :c, [:arglist]]]]]
 
 
15)
block_pass_call_1
 
a.b(4, &c)
 
expected
  [:block_pass, [:call, nil, :c, [:arglist]], [:call, [:call, nil, :a, [:arglist]], :b, [:arglist, [:lit, 4]]]]
to equal
  [:call, [:call, nil, :a, [:arglist]], :b, [:arglist, [:lit, 4], [:block_pass, [:call, nil, :c, [:arglist]]]]]
 
 
16)
block_pass_call_n
 
a.b(1, 2, 3, &c)
 
expected
  [:block_pass, [:call, nil, :c, [:arglist]], [:call, [:call, nil, :a, [:arglist]], :b, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3]]]]
to equal
  [:call, [:call, nil, :a, [:arglist]], :b, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3], [:block_pass, [:call, nil, :c, [:arglist]]]]]
 
 
17)
block_pass_fcall_0
 
a(&b)
 
expected
  [:block_pass, [:call, nil, :b, [:arglist]], [:call, nil, :a, [:arglist]]]
to equal
  [:call, nil, :a, [:arglist, [:block_pass, [:call, nil, :b, [:arglist]]]]]
 
 
18)
block_pass_fcall_1
 
a(4, &b)
 
expected
  [:block_pass, [:call, nil, :b, [:arglist]], [:call, nil, :a, [:arglist, [:lit, 4]]]]
to equal
  [:call, nil, :a, [:arglist, [:lit, 4], [:block_pass, [:call, nil, :b, [:arglist]]]]]
 
 
19)
block_pass_fcall_n
 
a(1, 2, 3, &b)
 
expected
  [:block_pass, [:call, nil, :b, [:arglist]], [:call, nil, :a, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3]]]]
to equal
  [:call, nil, :a, [:arglist, [:lit, 1], [:lit, 2], [:lit, 3], [:block_pass, [:call, nil, :b, [:arglist]]]]]
 
 
20)
block_pass_omgwtf
 
define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })
 
expected
  [:block_pass, [:iter, [:call, [:const, :Proc], :new, [:arglist]], [:masgn, [:lasgn, :args]], [:nil]], [:call, nil, :define_attr_method, [:arglist, [:lit, :x], [:lit, :sequence_name]]]]
to equal
  [:call, nil, :define_attr_method, [:arglist, [:lit, :x], [:lit, :sequence_name], [:block_pass, [:iter, [:call, [:const, :Proc], :new, [:arglist]], [:masgn, [:array, [:splat, [:lasgn, :args]]]], [:nil]]]]]
 
 
21)
block_pass_splat
 
def blah(*args, &block)
  other(*args, &block)
end
 
expected
  [:defn, :blah, [:args, :*, [:block_arg, :block]], [:scope, [:block, [:block_pass, [:lvar, :block], [:call, nil, :other, [:splat, [:lvar, :args]]]]]]]
to equal
  [:defn, :blah, [:args, :"*args", :"&block"], [:scope, [:block, [:call, nil, :other, [:arglist, [:splat, [:lvar, :args]], [:block_pass, [:lvar, :block]]]]]]]
 
 
22)
block_pass_thingy
 
r.read_body(dest, &block)
 
expected
  [:block_pass, [:call, nil, :block, [:arglist]], [:call, [:call, nil, :r, [:arglist]], :read_body, [:arglist, [:call, nil, :dest, [:arglist]]]]]
to equal
  [:call, [:call, nil, :r, [:arglist]], :read_body, [:arglist, [:call, nil, :dest, [:arglist]], [:block_pass, [:call, nil, :block, [:arglist]]]]]
 
 
23)
block_stmt_before_mri_verbose_flag
 
def f
  a
  begin
    b
  rescue
    c
  end
end
 
expected
  [:defn, :f, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]], [:begin, [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]]]
to equal
  [:defn, :f, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]], [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]]
 
 
24)
block_stmt_before
 
def f
  a
  begin
    b
  rescue
    c
  end
end
 
expected
  [:defn, :f, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]], [:begin, [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]]]
to equal
  [:defn, :f, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]], [:rescue, [:call, nil, :b, [:arglist]], [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]]
 
 
25)
call_arglist_norm_hash_splat
 
o.m(42, :a => 1, :b => 2, *c)
 
expected
  [:call, [:call, nil, :o, [:arglist]], :m, [:argscat, [:array, [:lit, 42], [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]], [:call, nil, :c, [:arglist]]]]
to equal
  [:call, [:call, nil, :o, [:arglist]], :m, [:arglist, [:lit, 42], [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]], [:splat, [:call, nil, :c, [:arglist]]]]]
 
 
26)
call_index_space
 
a = []
a [42]
 
 
expected
  [:block, [:lasgn, :a, [:zarray]], [:call, nil, :a, [:arglist, [:array, [:lit, 42]]]]]
to equal
  [:block, [:lasgn, :a, [:array]], [:call, [:lvar, :a], :[], [:arglist, [:lit, 42]]]]
 
 
27)
call_index
 
a = []
a[42]
 
 
expected
  [:block, [:lasgn, :a, [:zarray]], [:call, [:lvar, :a], :[], [:arglist, [:lit, 42]]]]
to equal
  [:block, [:lasgn, :a, [:array]], [:call, [:lvar, :a], :[], [:arglist, [:lit, 42]]]]
 
 
28)
dasgn_2
 
a.each do |x|
  if true then
    c = 0
    b.each { |y| c = (c + 1) }
  end
end
 
expected
  [:iter, [:call, [:call, nil, :a, [:arglist]], :each, [:arglist]], [:lasgn, :x], [:if, [:true], [:block, [:lasgn, :c, [:fixnum, 0]], [:iter, [:call, [:call, nil, :b, [:arglist]], :each, [:arglist]], [:lasgn, :y], [:lasgn, :c, [:call, [:lvar, :c], :+, [:arglist, [:lit, 1]]]]]], nil]]
to equal
  [:iter, [:call, [:call, nil, :a, [:arglist]], :each, [:arglist]], [:lasgn, :x], [:if, [:true], [:block, [:lasgn, :c, [:lit, 0]], [:iter, [:call, [:call, nil, :b, [:arglist]], :each, [:arglist]], [:lasgn, :y], [:lasgn, :c, [:call, [:lvar, :c], :+, [:arglist, [:lit, 1]]]]]], nil]]
 
 
29)
dasgn_icky
 
a do
  v = nil
  assert_block(full_message) do
    begin
      yield
    rescue Exception => v
      break
    end
  end
end
 
expected
  [:iter, [:call, nil, :a, [:arglist]], nil, [:block, [:lasgn, :v, [:nil]], [:iter, [:call, nil, :assert_block, [:arglist, [:call, nil, :full_message, [:arglist]]]], nil, [:begin, [:rescue, [:yield], [:resbody, [:array, [:const, :Exception], [:lasgn, :v, [:gvar, :$!]]], [:block, [:break]]]]]]]]
to equal
  [:iter, [:call, nil, :a, [:arglist]], nil, [:block, [:lasgn, :v, [:nil]], [:iter, [:call, nil, :assert_block, [:arglist, [:call, nil, :full_message, [:arglist]]]], nil, [:rescue, [:yield], [:resbody, [:array, [:const, :Exception], [:lasgn, :v, [:gvar, :$!]]], [:break]]]]]]
 
 
30)
dasgn_mixed
 
t = 0
ns.each { |n| t += n }
 
 
expected
  [:block, [:lasgn, :t, [:fixnum, 0]], [:iter, [:call, [:call, nil, :ns, [:arglist]], :each, [:arglist]], [:lasgn, :n], [:lasgn, :t, [:call, [:lvar, :t], :+, [:arglist, [:lvar, :n]]]]]]
to equal
  [:block, [:lasgn, :t, [:lit, 0]], [:iter, [:call, [:call, nil, :ns, [:arglist]], :each, [:arglist]], [:lasgn, :n], [:lasgn, :t, [:call, [:lvar, :t], :+, [:arglist, [:lvar, :n]]]]]]
 
 
31)
defn_args_block
 
def f(&block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :"&block"], [:scope, [:block, [:nil]]]]
 
 
32)
defn_args_mand_block
 
def f(mand, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :"&block"], [:scope, [:block, [:nil]]]]
 
 
33)
defn_args_mand_opt_block
 
def f(mand, opt = 42, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, :opt, [:block, [:lasgn, :opt, [:lit, 42]]], [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
34)
defn_args_mand_opt_splat_block
 
def f(mand, opt = 42, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]], [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :opt, :"*rest", :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
35)
defn_args_mand_opt_splat_no_name
 
def x(a, b = 42, *)
  # do nothing
end
 
expected
  [:defn, :x, [:args, :a, :b, [:block, [:lasgn, :b, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :x, [:args, :a, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
36)
defn_args_mand_opt_splat
 
def f(mand, opt = 42, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
37)
defn_args_mand_splat_block
 
def f(mand, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, :*, [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :"*rest", :"&block"], [:scope, [:block, [:nil]]]]
 
 
38)
defn_args_mand_splat_no_name
 
def x(a, *args)
  p(a, args)
end
 
expected
  [:defn, :x, [:args, :a, :*], [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a], [:lvar, :args]]]]]]
to equal
  [:defn, :x, [:args, :a, :"*args"], [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a], [:lvar, :args]]]]]]
 
 
39)
defn_args_mand_splat
 
def f(mand, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :mand, :*], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :mand, :"*rest"], [:scope, [:block, [:nil]]]]
 
 
40)
defn_args_opt_block
 
def f(opt = 42, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :opt, [:block, [:lasgn, :opt, [:lit, 42]]], [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
41)
defn_args_opt_splat_block
 
def f(opt = 42, *rest, &block)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]], [:block_arg, :block]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :opt, :"*rest", :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
42)
defn_args_opt_splat_no_name
 
def x(b = 42, *)
  # do nothing
end
 
expected
  [:defn, :x, [:args, :b, [:block, [:lasgn, :b, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :x, [:args, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
43)
defn_args_opt_splat
 
def f(opt = 42, *rest)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :opt, :*, [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]], [:scope, [:block, [:nil]]]]
 
 
44)
defn_args_splat_no_name
 
def x(*)
  # do nothing
end
 
expected
  [:defn, :x, [:args], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :x, [:args, :*], [:scope, [:block, [:nil]]]]
 
 
45)
defn_args_splat
 
def f(*rest)
  # do nothing
end
 
expected
  [:defn, :f, [:args, :*], [:scope, [:block, [:nil]]]]
to equal
  [:defn, :f, [:args, :"*rest"], [:scope, [:block, [:nil]]]]
 
 
46)
defn_splat_no_name
 
def x(a, *)
  p(a)
end
 
expected
  [:defn, :x, [:args, :a], [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a]]]]]]
to equal
  [:defn, :x, [:args, :a, :*], [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a]]]]]]
 
 
47)
defn_zarray
 
def zarray
  a = []
  return a
end
 
expected
  [:defn, :zarray, [:args], [:scope, [:block, [:lasgn, :a, [:zarray]], [:return, [:lvar, :a]]]]]
to equal
  [:defn, :zarray, [:args], [:scope, [:block, [:lasgn, :a, [:array]], [:return, [:lvar, :a]]]]]
 
 
48)
defs_empty_args
 
def self.empty(*)
  # do nothing
end
 
expected
  [:defs, [:self], :empty, [:args], [:scope, [:block]]]
to equal
  [:defs, [:self], :empty, [:args, :*], [:scope, [:block]]]
 
 
49)
defs_expr_wtf
 
def (a.b).empty(*)
  # do nothing
end
 
expected
  [:defs, [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]], :empty, [:args], [:scope, [:block]]]
to equal
  [:defs, [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]], :empty, [:args, :*], [:scope, [:block]]]
 
 
50)
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"]]
 
 
51)
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, [:arglist]]], [:str, " ("], [:evstr, [:call, [:gvar, :$!], :class, [:arglist]]], [:str, ")"]]
to equal
  [:dstr, "blah(string):", [:evstr, [:lit, 1]], [:str, ": warning: "], [:evstr, [:call, [:gvar, :$!], :message, [:arglist]]], [:str, " ("], [:evstr, [:call, [:gvar, :$!], :class, [:arglist]]], [:str, ")"]]
 
 
52)
dstr_the_revenge
 
"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"
 
expected
  [:dstr, "before ", [:evstr, [:call, nil, :from, [:arglist]]], [:str, " middle "], [:evstr, [:call, nil, :to, [:arglist]]], [:str, " ("], [:evstr, [:file]], [:str, ":"], [:evstr, [:fixnum, 1]], [:str, ")"]]
to equal
  [:dstr, "before ", [:evstr, [:call, nil, :from, [:arglist]]], [:str, " middle "], [:evstr, [:call, nil, :to, [:arglist]]], [:str, " ("], [:str, "(string)"], [:str, ":"], [:evstr, [:lit, 1]], [:str, ")"]]
 
 
53)
ensure
 
begin
  (1 + 1)
rescue SyntaxError => e1
  2
rescue Exception => e2
  3
else
  4
ensure
  5
end
 
expected
  [:begin, [:ensure, [:rescue, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]], [:resbody, [:array, [:const, :SyntaxError], [:lasgn, :e1, [:gvar, :$!]]], [:block, [:lit, 2]], [:resbody, [:array, [:const, :Exception], [:lasgn, :e2, [:gvar, :$!]]], [:block, [:lit, 3]]]], [:lit, 4]], [:lit, 5]]]
to equal
  [:ensure, [:rescue, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]], [:resbody, [:array, [:const, :SyntaxError], [:lasgn, :e1, [:gvar, :$!]]], [:lit, 2]], [:resbody, [:array, [:const, :Exception], [:lasgn, :e2, [:gvar, :$!]]], [:lit, 3]], [:lit, 4]], [:lit, 5]]
 
 
54)
fcall_arglist_norm_hash_splat
 
m(42, :a => 1, :b => 2, *c)
 
expected
  [:call, nil, :m, [:argscat, [:array, [:lit, 42], [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]], [:call, nil, :c, [:arglist]]]]
to equal
  [:call, nil, :m, [:arglist, [:lit, 42], [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]], [:splat, [:call, nil, :c, [:arglist]]]]]
 
 
55)
flip2
 
x = if ((i % 4) == 0)..((i % 3) == 0) then
  i
else
  nil
end
 
expected
  [:lasgn, :x, [:if, [:flip2, [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 4]]], :==, [:arglist, [:fixnum, 0]]], [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 3]]], :==, [:arglist, [:fixnum, 0]]]], [:call, nil, :i, [:arglist]], [:nil]]]
to equal
  [:lasgn, :x, [:if, [:flip2, [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 4]]], :==, [:arglist, [:lit, 0]]], [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 3]]], :==, [:arglist, [:lit, 0]]]], [:call, nil, :i, [:arglist]], [:nil]]]
 
 
56)
flip3
 
x = if ((i % 4) == 0)...((i % 3) == 0) then
  i
else
  nil
end
 
expected
  [:lasgn, :x, [:if, [:flip3, [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 4]]], :==, [:arglist, [:fixnum, 0]]], [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 3]]], :==, [:arglist, [:fixnum, 0]]]], [:call, nil, :i, [:arglist]], [:nil]]]
to equal
  [:lasgn, :x, [:if, [:flip3, [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 4]]], :==, [:arglist, [:lit, 0]]], [:call, [:call, [:call, nil, :i, [:arglist]], :%, [:arglist, [:lit, 3]]], :==, [:arglist, [:lit, 0]]]], [:call, nil, :i, [:arglist]], [:nil]]]
 
 
57)
iter_masgn_args_splat_no_name
 
a { |b, c, *| p(c) }
 
expected
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:splat]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
to equal
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c], [:splat]]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
 
 
58)
iter_masgn_args_splat
 
a { |b, c, *d| p(c) }
 
expected
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lasgn, :d]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
to equal
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c], [:splat, [:lasgn, :d]]]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
 
 
59)
iter_masgn_splat_no_name
 
a { |*| p(c) }
 
expected
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:splat]], [:call, nil, :p, [:arglist, [:call, nil, :c, [:arglist]]]]]
to equal
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:splat]]], [:call, nil, :p, [:arglist, [:call, nil, :c, [:arglist]]]]]
 
 
60)
iter_masgn_splat
 
a { |*c| p(c) }
 
expected
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:lasgn, :c]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
to equal
  [:iter, [:call, nil, :a, [:arglist]], [:masgn, [:array, [:splat, [:lasgn, :c]]]], [:call, nil, :p, [:arglist, [:lvar, :c]]]]
 
 
61)
lit_long_negative
 
-1
 
expected
  [:negate, [:lit, 1]]
to equal
  [:lit, -1]
 
 
62)
lit_range2
 
(1..10)
 
expected
  [:dot2, [:lit, 1], [:lit, 10]]
to equal
  [:lit, 1..10]
 
 
63)
lit_range3
 
(1...10)
 
expected
  [:dot3, [:lit, 1], [:lit, 10]]
to equal
  [:lit, 1...10]
 
 
64)
lit_regexp_i_wwtt
 
str.split(//i)
 
expected
  [:call, [:call, nil, :str, [:arglist]], :split, [:arglist, [:regex, "", 1]]]
to equal
  [:call, [:call, nil, :str, [:arglist]], :split, [:arglist, [:lit, //i]]]
 
 
65)
lit_regexp_n
 
/x/n
 
expected
  [:regex, "x", 16]
to equal
  [:lit, /x/]
 
 
66)
lit_regexp_once
 
/x/o
 
expected
  [:regex, "x", 0]
to equal
  [:lit, /x/]
 
 
67)
lit_regexp
 
/x/
 
expected
  [:regex, "x", 0]
to equal
  [:lit, /x/]
 
 
68)
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, [:args], [:scope, [:block, [:iter, [:call, nil, :c, [:arglist]], nil, [:begin, [:rescue, [:call, nil, :do_stuff, [:arglist]], [:resbody, [:array, [:const, :RuntimeError], [:lasgn, :b, [:gvar, :$!]]], [:block, [:call, nil, :puts, [:arglist, [:lvar, :b]]]]]]]]]]]]
to equal
  [:block, [:lasgn, :b, [:lit, 42]], [:defn, :a, [:args], [:scope, [:block, [:iter, [:call, nil, :c, [:arglist]], nil, [:rescue, [:call, nil, :do_stuff, [:arglist]], [:resbody, [:array, [:const, :RuntimeError], [:lasgn, :b, [:gvar, :$!]]], [:call, nil, :puts, [:arglist, [:lvar, :b]]]]]]]]]]
 
 
69)
masgn_argscat
 
a, b, *c = 1, 2, *[3, 4]
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:lasgn, :c], [:argscat, [:array, [:lit, 1], [:lit, 2]], [:array, [:lit, 3], [:lit, 4]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]], [:array, [:lit, 1], [:lit, 2], [:splat, [:array, [:lit, 3], [:lit, 4]]]]]
 
 
70)
masgn_attrasgn_array_rhs
 
a.b, a.c, _ = q
 
expected
  [:masgn, [:array, [:attrasgn, [:call, nil, :a, [:arglist]], :b], [:attrasgn, [:call, nil, :a, [:arglist]], :c], [:lasgn, :_]], [:to_ary, [:call, nil, :q, [:arglist]]]]
to equal
  [:masgn, [:array, [:attrasgn, [:call, nil, :a, [:arglist]], :b=, [:arglist]], [:attrasgn, [:call, nil, :a, [:arglist]], :c=, [:arglist]], [:lasgn, :_]], [:to_ary, [:call, nil, :q, [:arglist]]]]
 
 
71)
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], :[], [:arglist, [:lvar, :j]]], [:call, [:lvar, :a], :[], [:arglist, [:lvar, :i]]]]]]
to equal
  [:block, [:masgn, [:array, [:lasgn, :a], [:lasgn, :i], [:lasgn, :j]], [:array, [:array], [:lit, 1], [:lit, 2]]], [:masgn, [:array, [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lvar, :i]]], [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lvar, :j]]]], [:array, [:call, [:lvar, :a], :[], [:arglist, [:lvar, :j]]], [:call, [:lvar, :a], :[], [:arglist, [:lvar, :i]]]]]]
 
 
72)
masgn_attrasgn
 
a, b.c = d, e
 
expected
  [:masgn, [:array, [:lasgn, :a], [:attrasgn, [:call, nil, :b, [:arglist]], :c]], [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:attrasgn, [:call, nil, :b, [:arglist]], :c=, [:arglist]]], [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]
 
 
73)
masgn_splat_no_name_to_ary
 
a, b, * = c
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:splat], [:to_ary, [:call, nil, :c, [:arglist]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:splat]], [:to_ary, [:call, nil, :c, [:arglist]]]]
 
 
74)
masgn_splat
 
a, b, *c = d, e, f, g
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:lasgn, :c], [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]], [:call, nil, :f, [:arglist]], [:call, nil, :g, [:arglist]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]], [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]], [:call, nil, :f, [:arglist]], [:call, nil, :g, [:arglist]]]]
 
 
75)
masgn_splat_to_ary2
 
a, b, *c = d.e("f")
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:lasgn, :c], [:to_ary, [:call, [:call, nil, :d, [:arglist]], :e, [:arglist, [:str, "f"]]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]], [:to_ary, [:call, [:call, nil, :d, [:arglist]], :e, [:arglist, [:str, "f"]]]]]
 
 
76)
masgn_splat_to_ary
 
a, b, *c = d
 
expected
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:lasgn, :c], [:to_ary, [:call, nil, :d, [:arglist]]]]
to equal
  [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]], [:to_ary, [:call, nil, :d, [:arglist]]]]
 
 
77)
match2
 
/x/ =~ "blah"
 
expected
  [:match2, [:regex, "x", 0], [:str, "blah"]]
to equal
  [:match2, [:lit, /x/], [:str, "blah"]]
 
 
78)
match3
 
"blah" =~ /x/
 
expected
  [:match3, [:regex, "x", 0], [:str, "blah"]]
to equal
  [:match3, [:lit, /x/], [:str, "blah"]]
 
 
79)
match
 
1 if /x/
 
expected
  [:if, [:match, "x", 0], [:lit, 1], nil]
to equal
  [:if, [:match, [:lit, /x/]], [:lit, 1], nil]
 
 
80)
op_asgn1_ivar
 
@b = []
@b[1] ||= 10
@b[2] &&= 11
@b[3] += 12
 
 
expected
  [:block, [:iasgn, :@b, [:zarray]], [:op_asgn1, [:ivar, :@b], [:array, [:lit, 1]], :"||", [:lit, 10]], [:op_asgn1, [:ivar, :@b], [:array, [:lit, 2]], :"&&", [:lit, 11]], [:op_asgn1, [:ivar, :@b], [:array, [:lit, 3]], :+, [:lit, 12]]]
to equal
  [:block, [:iasgn, :@b, [:array]], [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 1]], :"||", [:lit, 10]], [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]], [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
 
 
81)
op_asgn1
 
b = []
b[1] ||= 10
b[2] &&= 11
b[3] += 12
 
 
expected
  [:block, [:lasgn, :b, [:zarray]], [:op_asgn1, [:lvar, :b], [:array, [:lit, 1]], :"||", [:lit, 10]], [:op_asgn1, [:lvar, :b], [:array, [:lit, 2]], :"&&", [:lit, 11]], [:op_asgn1, [:lvar, :b], [:array, [:lit, 3]], :+, [:lit, 12]]]
to equal
  [:block, [:lasgn, :b, [:array]], [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]], [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]], [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
 
 
82)
op_asgn2_self
 
self.Bag ||= Bag.new
 
expected
  [:op_asgn2, [:self], :Bag, :"||", [:call, [:const, :Bag], :new, [:arglist]]]
to equal
  [:op_asgn2, [:self], :Bag=, :"||", [:call, [:const, :Bag], :new, [:arglist]]]
 
 
83)
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, [:arglist, [:lit, :var]]]], [:lasgn, :c, [:call, [:lvar, :s], :new, [:arglist, [: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, [:arglist]], :e, [:arglist]], :f, :"||", [:lit, 42]]]
to equal
  [:block, [:lasgn, :s, [:call, [:const, :Struct], :new, [:arglist, [:lit, :var]]]], [:lasgn, :c, [:call, [:lvar, :s], :new, [:arglist, [: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, [:arglist]], :e, [:arglist]], :f=, :"||", [:lit, 42]]]
 
 
84)
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]]]]
 
 
85)
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]]]]
 
 
86)
rescue_block_body_3
 
begin
  a
rescue A
  b
rescue B
  c
rescue C
  d
end
 
expected
  [:begin, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:const, :A]], [:call, nil, :b, [:arglist]], [:resbody, [:array, [:const, :B]], [:call, nil, :c, [:arglist]]], [:resbody, [:array, [:const, :C]], [:call, nil, :d, [:arglist]]]]]]
to equal
  [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:const, :A]], [:call, nil, :b, [:arglist]]], [:resbody, [:array, [:const, :B]], [:call, nil, :c, [:arglist]]], [:resbody, [:array, [:const, :C]], [:call, nil, :d, [:arglist]]]]
 
 
87)
rescue_block_body_ivar
 
begin
  a
rescue => @e
  c
  d
end
 
expected
  [:begin, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array], [:block, [:iasgn, :@e, [:gvar, :$!]], [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]]]
to equal
  [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:iasgn, :@e, [:gvar, :$!]]], [:block, [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]]
 
 
88)
rescue_block_body
 
begin
  a
rescue => e
  c
  d
end
 
expected
  [:begin, [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], [:block, [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]]]
to equal
  [:rescue, [:call, nil, :a, [:arglist]], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], [:block, [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]]
 
 
89)
rescue_block_nada
 
begin
  blah
rescue
  # do nothing
end
 
expected
  [:begin, [:rescue, [:call, nil, :blah, [:arglist]], [:resbody, [:array], nil]]]
to equal
  [:rescue, [:call, nil, :blah, [:arglist]], [:resbody, [:array], nil]]
 
 
90)
rescue_exceptions
 
begin
  blah
rescue RuntimeError => r
  # do nothing
end
 
expected
  [:begin, [:rescue, [:call, nil, :blah, [:arglist]], [:resbody, [:array, [:const, :RuntimeError], [:lasgn, :r, [:gvar, :$!]]], nil]]]
to equal
  [:rescue, [:call, nil, :blah, [:arglist]], [:resbody, [:array, [:const, :RuntimeError], [:lasgn, :r, [:gvar, :$!]]], nil]]
 
 
91)
rescue_iasgn_var_empty
 
begin
  1
rescue => @e
  # do nothing
end
 
expected
  [:begin, [:rescue, [:lit, 1], [:resbody, [:array], [:iasgn, :@e, [:gvar, :$!]]]]]
to equal
  [:rescue, [:lit, 1], [:resbody, [:array, [:iasgn, :@e, [:gvar, :$!]]], nil]]
 
 
92)
rescue_lasgn
 
begin
  1
rescue
  var = 2
end
 
expected
  [:begin, [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :var, [:lit, 2]]], nil]]]
to equal
  [:rescue, [:lit, 1], [:resbody, [:array], [:lasgn, :var, [:lit, 2]]]]
 
 
93)
rescue_lasgn_var_empty
 
begin
  1
rescue => e
  # do nothing
end
 
expected
  [:begin, [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], nil]]]
to equal
  [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], nil]]
 
 
94)
rescue_lasgn_var
 
begin
  1
rescue => e
  var = 2
end
 
expected
  [:begin, [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], [:block, [:lasgn, :var, [:lit, 2]]]]]]
to equal
  [:rescue, [:lit, 1], [:resbody, [:array, [:lasgn, :e, [:gvar, :$!]]], [:lasgn, :var, [:lit, 2]]]]
 
 
95)
splat
 
def x(*b)
  a(*b)
end
 
expected
  [:defn, :x, [:args, :*], [:scope, [:block, [:call, nil, :a, [:splat, [:lvar, :b]]]]]]
to equal
  [:defn, :x, [:args, :"*b"], [:scope, [:block, [:call, nil, :a, [:arglist, [:splat, [:lvar, :b]]]]]]]
 
 
96)
str_interp_file
 
"file = #{__FILE__}\n"
 
expected
  [:dstr, "file = ", [:evstr, [:file]], [:str, "\n"]]
to equal
  [:str, "file = (string)\n"]
 
 
97)
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]]
 
 
98)
super_1_array
 
def x
  super([24, 42])
end
 
expected
  [:defn, :x, [:args], [:scope, [:block, [:super, [:array, [:array, [:lit, 24], [:lit, 42]]]]]]]
to equal
  [:defn, :x, [:args], [:scope, [:block, [:super, [:array, [:lit, 24], [:lit, 42]]]]]]
 
 
99)
super_1
 
def x
  super(4)
end
 
expected
  [:defn, :x, [:args], [:scope, [:block, [:super, [:array, [:lit, 4]]]]]]
to equal
  [:defn, :x, [:args], [:scope, [:block, [:super, [:lit, 4]]]]]
 
 
100)
super_block_pass
 
super(a, &b)
 
expected
  [:block_pass, [:call, nil, :b, [:arglist]], [:super, [:array, [:call, nil, :a, [:arglist]]]]]
to equal
  [:super, [:call, nil, :a, [:arglist]], [:block_pass, [:call, nil, :b, [:arglist]]]]
 
 
101)
super_block_splat
 
super(a, *b)
 
expected
  [:super, [:argscat, [:array, [:call, nil, :a, [:arglist]]], [:call, nil, :b, [:arglist]]]]
to equal
  [:super, [:call, nil, :a, [:arglist]], [:splat, [:call, nil, :b, [:arglist]]]]
 
 
102)
super_n
 
def x
  super(24, 42)
end
 
expected
  [:defn, :x, [:args], [:scope, [:block, [:super, [:array, [:lit, 24], [:lit, 42]]]]]]
to equal
  [:defn, :x, [:args], [:scope, [:block, [:super, [:lit, 24], [:lit, 42]]]]]
 
 
103)
yield_n
 
yield(42, 24)
 
expected
  [:yield, [:array, [:lit, 42], [:lit, 24]]]
to equal
  [:yield, [:lit, 42], [:lit, 24]]
 
 
104)
yield_zarray
 
yield([])
 
expected
  [:yield, [:zarray]]
to equal
  [:yield, [:array]]
 
 
105)
zarray
 
a = []
 
expected
  [:lasgn, :a, [:zarray]]
to equal
  [:lasgn, :a, [:array]]
 
 
Finished in 17.411131 seconds
 
308 examples, 104 failures, 1 errors
e