ParseTree 2.0.2 → 2.1.0

data/lib/sexp.rb

@@ -1,4 +1,3 @@
-require 'parse_tree'
 
 $TESTING ||= false # unless defined $TESTING
 
@@ -26,6 +25,7 @@ class Sexp < Array # ZenTest FULL
   # of +klass+ until a method definition is found.
 
   def self.for(klass, method = nil, walk_ancestors = false)
+    require 'parse_tree'
     sexp = if walk_ancestors and method then
              klass.ancestors.each do |klass|
                sexp = ParseTree.translate klass, method

data/lib/sexp_processor.rb

@@ -137,13 +137,12 @@ class SexpProcessor
     @warn_on_default = true
     @auto_shift_type = false
     @strict = false
-    @unsupported = [:alloca, :cfunc, :cref, :evstr, :ifunc, :last, :memo, :newline, :opt_n, :method] # internal nodes that you can't get to
+    @unsupported = [:alloca, :cfunc, :cref, :ifunc, :last, :memo, :newline, :opt_n, :method] # internal nodes that you can't get to
     @unsupported_checked = false
     @debug = {}
     @expected = Sexp
     @require_empty = true
     @exceptions = {}
-    @process_level = 0
 
     # we do this on an instance basis so we can subclass it for
     # different processors.
@@ -170,15 +169,19 @@ class SexpProcessor
   end
 
   def rewrite(exp)
+    type = exp.first
+
+    self.context.unshift type # FIX: first one doubles up because process already unshifted -- look at moving initial rewrite up above
     exp.map! { |sub| Array === sub ? rewrite(sub) : sub }
 
-    type = exp.first
     begin
       meth = @rewriters[type]
       exp  = self.send(meth, exp) if meth
       old_type, type = type, exp.first
     end until old_type == type
 
+    self.context.shift
+
     exp
   end
 
@@ -190,8 +193,6 @@ class SexpProcessor
   def process(exp)
     return nil if exp.nil?
 
-    @process_level += 1
-
     unless @unsupported_checked then
       m = public_methods.grep(/^process_/) { |o| o.sub(/^process_/, '').intern }
       supported = m - (m - @unsupported)
@@ -207,7 +208,7 @@ class SexpProcessor
     raise "type should be a Symbol, not: #{exp.first.inspect}" unless
       Symbol === type
 
-    @context.unshift type
+    self.context.unshift type
 
     if @debug.has_key? type then
       str = exp.inspect
@@ -220,7 +221,7 @@ class SexpProcessor
 
     raise UnsupportedNodeError, "'#{type}' is not a supported node type" if @unsupported.include? type
 
-    exp = self.rewrite(exp) if @process_level == 1
+    exp = self.rewrite(exp) if self.context.size == 1
 
     if @debug.has_key? type then
       str = exp.inspect
@@ -276,9 +277,7 @@ class SexpProcessor
       end
     end
 
-    @process_level -= 1
-
-    @context.shift
+    self.context.shift
     result
   end
 
@@ -291,7 +290,7 @@ class SexpProcessor
 
   def assert_type(list, typ)
     raise SexpTypeError, "Expected type #{typ.inspect} in #{list.inspect}" if
-      list.first != typ
+      not Array === list or list.first != typ
   end
 
   def error_handler(type, exp=nil) # :nodoc:

data/lib/unified_ruby.rb

@@ -105,11 +105,17 @@ module UnifiedRuby
   end
 
   def rewrite_defs(exp)
-    # move args up
-    args = exp.scope.block.args(true) rescue nil
-    exp.insert 3, args if args
+    receiver = exp.delete_at 1
 
-    exp
+    # TODO: I think this would be better as rewrite_scope, but that breaks others
+    exp = s(exp.shift, exp.shift,
+            s(:scope,
+              s(:block, exp.scope.args))) if exp.scope.args
+
+    result = rewrite_defn(exp)
+    result.insert 1, receiver
+
+    result
   end
 
   def rewrite_dmethod(exp)
@@ -180,3 +186,11 @@ module UnifiedRuby
     rewrite_fcall(exp)
   end
 end
+
+##
+# Quick and easy SexpProcessor that unified the sexp structure.
+
+class Unifier < SexpProcessor
+  include UnifiedRuby
+end
+

data/test/pt_testcase.rb

@@ -4,6 +4,9 @@ require 'test/unit/testcase'
 require 'sexp_processor' # for deep_clone
 require 'unique'
 
+# key:
+# wwtt = what were they thinking?
+
 class Examples
   attr_reader :reader
   attr_writer :writer
@@ -71,12 +74,26 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby2Ruby"   => "class X\n  alias_method :y, :x\nend",
     },
 
+    "alias_ugh"  => {
+      "Ruby"        => "class X\n  alias y x\nend",
+      "ParseTree"   => [:class, :X, nil,
+                        [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
+      "Ruby2Ruby"   => "class X\n  alias_method :y, :x\nend",
+    },
+
     "and"  => {
       "Ruby"        => "(a and b)",
       "ParseTree"   => [:and, [:vcall, :a], [:vcall, :b]],
     },
 
-    "argscat"  => {
+    "argscat_inside"  => {
+      "Ruby"        => "a = [b, *c]",
+      "ParseTree"   => [:lasgn, :a,
+                        [:argscat, [:array, [:vcall, :b]], [:vcall, :c]]],
+      "Ruby2Ruby"   => "a = b, *c",
+    },
+
+    "argscat_svalue"  => {
       "Ruby"        => "a = b, c, *d",
       "ParseTree"   => [:lasgn, :a,
                         [:svalue,
@@ -98,6 +115,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:array, [:lit, 1], [:lit, :b], [:str, "c"]],
     },
 
+    "array_pct_W"  => {
+      "Ruby"        => "%W[--remove #\{@gem_repo}]",
+      "ParseTree"   => [:array,
+                        [:str, "--remove"],
+                        [:dstr, "", [:evstr, [:ivar, :@gem_repo]]]],
+      "Ruby2Ruby"   => "[\"--remove\", \"#\{@gem_repo}\"]",
+    },
+
     "attrasgn" => {
       "Ruby"        => "y = 0\n42.method = y\n",
       "ParseTree"   => [:block,
@@ -130,8 +155,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:begin, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
     },
 
+    "begin_def"  => {
+      "Ruby"        => "def m\n  begin\n\n  end\nend",
+      "ParseTree"   => [:defn, :m, [:scope, [:block, [:args], [:nil]]]],
+      "Ruby2Ruby"   => "def m\n  # do nothing\nend",
+    },
+
     "begin_rescue_ensure" => {
-      "Ruby" => "begin\n    rescue\n      # do nothing\n  ensure\n    nil\nend",
+      "Ruby" => "begin\nrescue\n  # do nothing\nensure\n  nil\nend",
       "ParseTree" => [:begin,
                        [:ensure,
                          [:rescue,
@@ -139,6 +170,18 @@ class ParseTreeTestCase < Test::Unit::TestCase
                            [:nil]]]
     },
 
+    "begin_rescue_twice" => { # testing block/begin processing really
+      "Ruby" => "begin\nrescue => mes\n  # do nothing\nend\nbegin\nrescue => mes\n  # do nothing\nend\n",
+      "ParseTree" => [:block,
+                      [:rescue,
+                       [:resbody, nil,
+                        [:lasgn, :mes, [:gvar, :$!]]]],
+                      [:begin,
+                       [:rescue,
+                        [:resbody, nil,
+                         [:lasgn, :mes, [:gvar, :$!]]]]]],
+    },
+
     "block_lasgn" => {
       "Ruby"        => "x = (y = 1\n(y + 2))",
       "ParseTree"   => [:lasgn, :x,
@@ -147,9 +190,23 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:call, [:lvar, :y], :+, [:array, [:lit, 2]]]]],
     },
 
-    "block_pass"  => {
-      "Ruby"        => "a(&b)",
-      "ParseTree"   => [:block_pass, [:vcall, :b], [:fcall, :a]],
+    "block_mystery_block"  => { # FIX: I don't like that extra return
+      "Ruby"        => "a(b) do\n  if b then\n    true\n  else\n    c = false\n    d { |x| c = true }\n    c\n  \n  end\nend",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a, [:array, [:vcall, :b]]],
+                        nil,
+                        [:block,
+                         [:dasgn_curr, :c],
+                         [:if,
+                          [:vcall, :b],
+                          [:true],
+                          [:block,
+                           [:dasgn_curr, :c, [:false]],
+                           [:iter,
+                            [:fcall, :d],
+                            [:dasgn_curr, :x],
+                            [:dasgn, :c, [:true]]],
+                           [:dvar, :c]]]]],
     },
 
     "block_pass_args_and_splat" => {
@@ -165,6 +222,46 @@ class ParseTreeTestCase < Test::Unit::TestCase
                           [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]],
     },
 
+    "block_pass_call_0"  => {
+      "Ruby"        => "a.b(&c)",
+      "ParseTree"   => [:block_pass, [:vcall, :c], [:call, [:vcall, :a], :b]],
+    },
+
+    "block_pass_call_1"  => {
+      "Ruby"        => "a.b(4, &c)",
+      "ParseTree"   => [:block_pass,
+                        [:vcall, :c],
+                        [:call, [:vcall, :a], :b, [:array, [:lit, 4]]]],
+    },
+
+    "block_pass_call_n"  => {
+      "Ruby"        => "a.b(1, 2, 3, &c)",
+      "ParseTree"   => [:block_pass,
+                        [:vcall, :c],
+                        [:call, [:vcall, :a], :b,
+                         [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
+    },
+
+    "block_pass_fcall_0"  => {
+      "Ruby"        => "a(&b)",
+      "ParseTree"   => [:block_pass, [:vcall, :b], [:fcall, :a]],
+    },
+
+    "block_pass_fcall_1"  => {
+      "Ruby"        => "a(4, &b)",
+      "ParseTree"   => [:block_pass,
+                        [:vcall, :b],
+                        [:fcall, :a, [:array, [:lit, 4]]]],
+    },
+
+    "block_pass_fcall_n"  => {
+      "Ruby"        => "a(1, 2, 3, &b)",
+      "ParseTree"   => [:block_pass,
+                        [:vcall, :b],
+                        [:fcall, :a,
+                         [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
+    },
+
     "block_pass_omgwtf" => {
       "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
       "ParseTree" => [:block_pass,
@@ -188,6 +285,52 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:fcall, :other, [:splat, [:lvar, :args]]]]]]],
     },
 
+    "block_pass_thingy" => {
+      "Ruby"      => "r.read_body(dest, &block)",
+      "ParseTree" => [:block_pass,
+                      [:vcall, :block],
+                      [:call, [:vcall, :r], :read_body,
+                       [:array, [:vcall, :dest]]]],
+    },
+
+    "block_stmt_after"  => {
+      "Ruby"        => "def f\n  begin\n    b\n  rescue\n    c\n  end\n\n  d\nend",
+      "ParseTree"   => [:defn,
+                        :f,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]],
+                          [:vcall, :d]]]],
+      "Ruby2Ruby"   => "def f\n  b rescue c\n  d\nend",
+    },
+
+    "block_stmt_before"  => {
+      "Ruby"        => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\nend",
+      "ParseTree"   => [:defn,
+                        :f,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:vcall, :a],
+                          [:begin,
+                           [:rescue, [:vcall, :b],
+                            [:resbody, nil, [:vcall, :c]]]]]]],
+    },
+
+    "block_stmt_both"  => {
+      "Ruby"        => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\n  d\nend",
+      "ParseTree"   => [:defn,
+                        :f,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:vcall, :a],
+                          [:rescue, [:vcall, :b], [:resbody, nil, [:vcall, :c]]],
+                          [:vcall, :d]]]],
+      "Ruby2Ruby"   => "def f\n  a\n  b rescue c\n  d\nend",
+    },
+
     "bmethod"  => {
       "Ruby"        => [Examples, :unsplatted],
       "ParseTree"   => [:defn,
@@ -238,8 +381,41 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "call_arglist"  => {
-      "Ruby"        => "puts(42)",
-      "ParseTree"   => [:fcall, :puts, [:array, [:lit, 42]]],
+      "Ruby"        => "o.puts(42)",
+      "ParseTree"   => [:call, [:vcall, :o], :puts, [:array, [:lit, 42]]],
+    },
+
+    "call_arglist_hash"  => {
+      "Ruby"        => "o.m(:a => 1, :b => 2)",
+      "ParseTree"   => [:call,
+                        [:vcall, :o], :m,
+                        [:array,
+                         [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]],
+    },
+
+    "call_arglist_norm_hash"  => {
+      "Ruby"        => "o.m(42, :a => 1, :b => 2)",
+      "ParseTree"   => [:call,
+                        [:vcall, :o], :m,
+                        [:array,
+                         [:lit, 42],
+                         [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]],
+    },
+
+    "call_arglist_norm_hash_splat"  => {
+      "Ruby"        => "o.m(42, :a => 1, :b => 2, *c)",
+      "ParseTree"   => [:call,
+                        [:vcall, :o], :m,
+                        [:argscat,
+                         [:array,
+                          [:lit, 42],
+                          [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]],
+                         [:vcall, :c]]],
+    },
+
+    "call_command" => {
+      "Ruby"        => "1.b(c)",
+      "ParseTree"   => [:call, [:lit, 1], :b, [:array, [:vcall, :c]]],
     },
 
     "call_expr" => {
@@ -255,6 +431,19 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:call, [:vcall, :a], :[], [:array, [:lit, 42]]],
     },
 
+    "call_index_no_args" => {
+      "Ruby"        => "a[]",
+      "ParseTree" => [:call, [:vcall, :a], :[]],
+    },
+
+    "call_unary_neg" => {
+      "Ruby"        => "-2**31",
+      "ParseTree"   => [:call,
+                        [:call, [:lit, 2], :**, [:array, [:lit, 31]]],
+                        :-@],
+      "Ruby2Ruby"   => "-(2 ** 31)",
+    },
+
     "case" => {
       "Ruby"        => "var = 2\nresult = \"\"\ncase var\nwhen 1 then\n  puts(\"something\")\n  result = \"red\"\nwhen 2, 3 then\n  result = \"yellow\"\nwhen 4 then\n  # do nothing\nelse\n  result = \"green\"\nend\ncase result\nwhen \"red\" then\n  var = 1\nwhen \"yellow\" then\n  var = 2\nwhen \"green\" then\n  var = 3\nelse\n  # do nothing\nend\n",
       "ParseTree" => [:block,
@@ -310,17 +499,38 @@ class ParseTreeTestCase < Test::Unit::TestCase
                        [:lasgn, :result, [:lit, 7]]]]
     },
 
+    "case_nested_inner_no_expr"  => {
+      "Ruby"        => "case a\nwhen b then\n  case\n  when (d and e) then\n    f\n  else\n    # do nothing\n  end\nelse\n  # do nothing\nend",
+      "ParseTree"   => [:case, [:vcall, :a],
+                        [:when, [:array, [:vcall, :b]],
+                         [:case, nil,
+                          [:when, [:array, [:and, [:vcall, :d], [:vcall, :e]]],
+                           [:vcall, :f]],
+                          nil]],
+                        nil],
+    },
+
     "case_no_expr" => { # TODO: nested
-      "Ruby" => "case\nwhen 1 then\n  :a\nwhen 2 then\n  :b\nelse\n  :c\nend",
+      "Ruby" => "case\nwhen (a == 1) then\n  :a\nwhen (a == 2) then\n  :b\nelse\n  :c\nend",
       "ParseTree" => [:case, nil,
                       [:when,
-                       [:array, [:lit, 1]],
+                       [:array, [:call, [:vcall, :a], :==, [:array, [:lit, 1]]]],
                        [:lit, :a]],
                       [:when,
-                       [:array, [:lit, 2]], [:lit, :b]],
+                       [:array, [:call, [:vcall, :a], :==, [:array, [:lit, 2]]]],
+                       [:lit, :b]],
                       [:lit, :c]],
     },
 
+    "case_splat" => {
+      "Ruby" => "case a\nwhen :b, *c then\n  d\nelse\n  e\nend",
+      "ParseTree" => [:case, [:vcall, :a],
+                      [:when,
+                       [:array, [:lit, :b], [:when, [:vcall, :c], nil]], # wtf?
+                       [:vcall, :d]],
+                      [:vcall, :e]],
+    },
+
     "cdecl"  => {
       "Ruby"        => "X = 42",
       "ParseTree"   => [:cdecl, :X, [:lit, 42]],
@@ -416,6 +626,52 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"  => [:if, [:true], nil, [:if, [:false], [:return], nil]],
     },
 
+    "conditional_post_if"  => {
+      "Ruby"        => "a if b",
+      "ParseTree"   => [:if, [:vcall, :b], [:vcall, :a], nil],
+    },
+
+    "conditional_post_if_not"  => {
+      "Ruby"        => "a if not b",
+      "ParseTree"   => [:if, [:vcall, :b], nil, [:vcall, :a]],
+      "Ruby2Ruby"   => "a unless b"
+    },
+
+    "conditional_post_unless"  => {
+      "Ruby"        => "a unless b",
+      "ParseTree"   => [:if, [:vcall, :b], nil, [:vcall, :a]],
+    },
+
+    "conditional_post_unless_not"  => {
+      "Ruby"        => "a unless not b",
+      "ParseTree"   => [:if, [:vcall, :b], [:vcall, :a], nil],
+      "Ruby2Ruby"   => "a if b"
+    },
+
+    "conditional_pre_if"  => {
+      "Ruby"        => "if b then a end",
+      "ParseTree"   => [:if, [:vcall, :b], [:vcall, :a], nil],
+      "Ruby2Ruby"   => "a if b"
+    },
+
+    "conditional_pre_if_not"  => {
+      "Ruby"        => "if not b then a end",
+      "ParseTree"   => [:if, [:vcall, :b], nil, [:vcall, :a]],
+      "Ruby2Ruby"   => "a unless b"
+    },
+
+    "conditional_pre_unless"  => {
+      "Ruby"        => "unless b then a end",
+      "ParseTree"   => [:if, [:vcall, :b], nil, [:vcall, :a]],
+      "Ruby2Ruby"   => "a unless b"
+    },
+
+    "conditional_pre_unless_not"  => {
+      "Ruby"        => "unless not b then a end",
+      "ParseTree"   => [:if, [:vcall, :b], [:vcall, :a], nil],
+      "Ruby2Ruby"   => "a if b"
+    },
+
     "const"  => {
       "Ruby"        => "X",
       "ParseTree"   => [:const, :X],
@@ -433,22 +689,81 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:block, [:args], [:cvasgn, :@@blah, [:lit, 1]]]]]
     },
 
+    "cvasgn_cls_method" => {
+      "Ruby"        => "def self.quiet_mode=(boolean)\n  @@quiet_mode = boolean\nend",
+      "ParseTree"   => [:defs, [:self], :quiet_mode=, [:scope, [:block, [:args, :boolean], [:cvasgn, :@@quiet_mode, [:lvar, :boolean]]]]],
+    },
+
     "cvdecl"  => {
       "Ruby"        => "class X\n  @@blah = 1\nend",
       "ParseTree"   => [:class, :X, nil,
                         [:scope, [:cvdecl, :@@blah, [:lit, 1]]]],
     },
 
-    "dasgn"  => {
-      "Ruby"        => "a.each { |x| b.each { |y| x = (x + 1) } }",
+    "dasgn_0"  => {
+      "Ruby"        => "a.each { |x| b.each { |y| x = (x + 1) } if true }",
       "ParseTree"   => [:iter,
                         [:call, [:vcall, :a], :each],
                         [:dasgn_curr, :x],
-                        [:iter,
-                         [:call, [:vcall, :b], :each],
-                         [:dasgn_curr, :y],
-                         [:dasgn, :x,
-                          [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]],
+                        [:if, [:true],
+                         [:iter,
+                          [:call, [:vcall, :b], :each],
+                          [:dasgn_curr, :y],
+                          [:dasgn, :x,
+                           [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
+                         nil]],
+    },
+
+    "dasgn_1"  => { # without mystery block / dasgn_curr
+      "Ruby"        => "a.each { |x| b.each { |y| c = (c + 1) } if true }",
+      "ParseTree"   => [: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]],
+    },
+
+    "dasgn_2"  => { # WITH mystery block / dasgn_curr
+      "Ruby"        => "a.each do |x|\n  if true then\n    c = 0\n    b.each { |y| c = (c + 1) }\n  \n  end\nend", # FIX: hate that extra newline!
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :a], :each],
+                        [:dasgn_curr, :x],
+                        [:block,
+                         [:dasgn_curr, :c],
+                         [: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]]],
+    },
+
+    "dasgn_icky"  => { # WITH mystery block / dasgn_curr
+      "Ruby"        => "a do\n  v = nil\n  assert_block(full_message) do\n    begin\n      yield\n    rescue Exception => v\n      break\n    end\n  end\nend",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        nil,
+                        [:block,
+                         [:dasgn_curr, :v],
+                         [: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]]]]]]]],
     },
 
     "dasgn_curr" => {
@@ -462,32 +777,122 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
     },
 
+    "dasgn_mixed" => {
+      "Ruby"        => "t = 0\nns.each { |n| t += n }\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :t, [:lit, 0]],
+                        [:iter,
+                         [:call, [:vcall, :ns], :each],
+                         [:dasgn_curr, :n],
+                         [:lasgn, :t,
+                          [:call, [:lvar, :t], :+, [:array, [:dvar, :n]]]]]],
+      "Ruby2Ruby"   => "t = 0\nns.each { |n| t = (t + n) }\n",
+    },
+
     "defined"  => {
       "Ruby"        => "defined? $x",
       "ParseTree"   => [:defined, [:gvar, :$x]],
     },
 
-    "defn_args" => {
+    "defn_args_mand_opt_block" => {
+      "Ruby"      => "def x(a, b = 42, &d)\n  p(a, b, d)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :b,
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:block_arg, :d],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :b], [:lvar, :d]]]]]]
+    },
+
+    "defn_args_mand_opt_splat" => {
+      "Ruby"      => "def x(a, b = 42, *c)\n  p(a, b, c)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :b, :"*c",
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :b], [:lvar, :c]]]]]]
+    },
+
+    "defn_args_mand_opt_splat_block" => {
       "Ruby"      => "def x(a, b = 42, \*c, &d)\n  p(a, b, c, d)\nend",
       "ParseTree" => [:defn, :x,
                       [:scope,
                        [:block,
                         [:args, :a, :b, "*c".intern, # s->e
                          [:block, [:lasgn, :b, [:lit, 42]]]],
-                         [:block_arg, :d],
+                        [:block_arg, :d],
                         [:fcall, :p,
-                         [:array, [:lvar, :a], [:lvar, :b],
+                         [:array,
+                          [:lvar, :a], [:lvar, :b],
                           [:lvar, :c], [:lvar, :d]]]]]]
     },
 
+    "defn_args_mand_opt_splat_no_name" => {
+      "Ruby"      => "def x(a, b = 42, *)\n  p(a, b)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :b, :"*",
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :b]]]]]]
+    },
+
+    "defn_args_opt_block" => {
+      "Ruby"      => "def x(b = 42, &d)\n  p(b, d)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :b,
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:block_arg, :d],
+                        [:fcall, :p,
+                         [:array, [:lvar, :b], [:lvar, :d]]]]]]
+    },
+
+    "defn_args_opt_splat_no_name" => {
+      "Ruby"      => "def x(b = 42, *)\n  p(b)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :b, :"*",
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:fcall, :p,
+                         [:array, [:lvar, :b]]]]]]
+    },
+
     "defn_empty" => {
       "Ruby"        => "def empty\n  # do nothing\nend",
       "ParseTree"   => [:defn, :empty, [:scope, [:block, [:args], [:nil]]]],
     },
 
-    "defn_is_something" => {
-      "Ruby"        => "def something?\n  # do nothing\nend",
-      "ParseTree"   => [:defn, :something?, [:scope, [:block, [:args], [:nil]]]],
+    "defn_empty_args" => {
+      "Ruby"        => "def empty(*)\n  # do nothing\nend",
+      "ParseTree"   => [:defn, :empty, [:scope, [:block, [:args, :*], [:nil]]]],
+    },
+
+    "defn_lvar_boundary"  => { # FIX: add do nothing comment to block
+      "Ruby"        => "mes = 42\ndef instantiate_all\n  Thread.new do\n    begin\n    rescue RuntimeError => mes\n      puts(mes)\n    end\n  end\nend\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :mes, [:lit, 42]],
+                        [:defn, :instantiate_all,
+                         [:scope,
+                          [:block,
+                           [:args],
+                           [:iter,
+                            [:call, [:const, :Thread], :new],
+                            nil,
+                            [:begin,
+                             [:rescue,
+                              [:resbody,
+                               [:array, [:const, :RuntimeError]],
+                               [:block,
+                                [:dasgn_curr, :mes, [:gvar, :$!]],
+                                [:fcall, :puts, [:array, [:dvar, :mes]]]]]]]]]]]],
     },
 
     "defn_optargs" => {
@@ -506,7 +911,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "defn_rescue" => {
-      "Ruby" => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend",
+      "Ruby" => "def eql?(resource)\n  (self.uuid == resource.uuid)\nrescue\n  false\nend",
       "ParseTree" => [:defn, :eql?,
                       [:scope,
                        [:block,
@@ -517,6 +922,12 @@ class ParseTreeTestCase < Test::Unit::TestCase
                           :==,
                           [:array, [:call, [:lvar, :resource], :uuid]]],
                          [:resbody, nil, [:false]]]]]],
+      "Ruby2Ruby" => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend",
+    },
+
+    "defn_something_eh" => {
+      "Ruby"        => "def something?\n  # do nothing\nend",
+      "ParseTree"   => [:defn, :something?, [:scope, [:block, [:args], [:nil]]]],
     },
 
     "defn_splat_no_name" => {
@@ -546,6 +957,29 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:call, [:lvar, :y], :+, [:array, [:lit, 1]]]]]],
     },
 
+    "defs_args_mand_opt_splat_block" => {
+      "Ruby"      => "def self.x(a, b = 42, \*c, &d)\n  (a + b)\nend",
+      "ParseTree" => [:defs, [:self], :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :b, :"*c",
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                        [:block_arg, :d],
+                        [:call, [:lvar, :a], :+, [:array, [:lvar, :b]]]]]],
+    },
+
+    "defs_empty" => {
+      "Ruby"        => "def self.empty\n  # do nothing\nend",
+      "ParseTree"   => [:defs, [:self], :empty,
+                        [:scope, [:args]]],
+    },
+
+    "defs_empty_args" => {
+      "Ruby"        => "def self.empty(*)\n  # do nothing\nend",
+      "ParseTree"   => [:defs, [:self], :empty,
+                        [:scope, [:args, :*]]],
+    },
+
     "dmethod" => {
       "Ruby"        => [Examples, :dmethod_added],
       "ParseTree"   => [:defn,
@@ -572,47 +1006,136 @@ class ParseTreeTestCase < Test::Unit::TestCase
     "dregx"  => {
       "Ruby"        => "/x#\{(1 + 1)}y/",
       "ParseTree"   => [:dregx, "x",
-                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], [:str, "y"]],
+                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]], [:str, "y"]],
+    },
+
+    "dregx_interp" => {
+      "Ruby"        => "/#\{@rakefile}/",
+      "ParseTree"   => [:dregx, '', [:evstr, [:ivar, :@rakefile]]],
+    },
+
+    "dregx_n" => {
+      "Ruby"        => '/#{1}/n',
+      "ParseTree"   => [:dregx, '', [:evstr, [:lit, 1]], 16], # TODO: use consts
+      "Ruby2Ruby"   => "/#\{1}/", # HACK - need to support regexp flags
     },
 
     "dregx_once"  => {
       "Ruby"        => "/x#\{(1 + 1)}y/o",
       "ParseTree"   => [:dregx_once, "x",
-                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], [:str, "y"]],
+                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]], [:str, "y"]],
+    },
+
+    "dregx_once_n_interp" => {
+      "Ruby"        => "/#\{IAC}#\{SB}/no",
+      "ParseTree"   => [:dregx_once, '', [:evstr, [:const, :IAC]], [:evstr, [:const, :SB]], 16],
+      "Ruby2Ruby"   => "/#\{IAC}#\{SB}/o", # HACK
     },
 
     "dstr" => {
       "Ruby"        => "argl = 1\n\"x#\{argl}y\"\n",
       "ParseTree"   => [:block,
                         [:lasgn, :argl, [:lit, 1]],
-                        [:dstr, "x", [:lvar, :argl],
+                        [:dstr, "x", [:evstr, [:lvar, :argl]],
                          [:str, "y"]]],
     },
 
+    "dstr_2" => {
+      "Ruby"        => "argl = 1\n\"x#\{(\"%.2f\" % 3.14159)}y\"\n",
+      "ParseTree"   =>   [:block,
+                          [:lasgn, :argl, [:lit, 1]],
+                          [:dstr,
+                           "x",
+                           [:evstr, [:call, [:str, "%.2f"], :%, [:array, [:lit, 3.14159]]]],
+                           [:str, "y"]]],
+    },
+
+    "dstr_3" => {
+      "Ruby"        => "max = 2\nargl = 1\n\"x#\{(\"%.#\{max}f\" % 3.14159)}y\"\n",
+      "ParseTree"   =>   [:block,
+                          [:lasgn, :max, [:lit, 2]],
+                          [:lasgn, :argl, [:lit, 1]],
+                          [:dstr,
+                           "x",
+                           [:evstr, [:call,
+                            [:dstr, "%.", [:evstr, [:lvar, :max]], [:str, "f"]],
+                            :%, [:array, [:lit, 3.14159]]]],
+                           [:str, "y"]]],
+    },
+
+    "dstr_concat"  => {
+      "Ruby"        => '"#{22}aa" "cd#{44}" "55" "#{66}"',
+      "ParseTree"   => [:dstr,
+                        "",
+                        [:evstr, [:lit, 22]],
+                        [:str, "aa"],
+                        [:str, "cd"],
+                        [:evstr, [:lit, 44]],
+                        [:str, "55"],
+                        [:evstr, [:lit, 66]]],
+      "Ruby2Ruby"   => '"#{22}aacd#{44}55#{66}"',
+    },
+
+    "dstr_heredoc_yet_again"  => {
+      "Ruby"        => "<<-EOF\ns1 '#\{RUBY_PLATFORM}' s2\n#\{__FILE__}\n        EOF\n",
+      "ParseTree"   => [:dstr, "s1 '",
+                        [:evstr, [:const, :RUBY_PLATFORM]],
+                        [:str, "' s2\n"],
+                        [:str, "(string)"],
+                        [:str, "\n"]],
+      "Ruby2Ruby"   => "\"s1 '#\{RUBY_PLATFORM}' s2\\n(string)\\n\""
+    },
+
+    "dstr_nest"  => {
+      "Ruby"        => "%Q[before [#\{nest}] after]",
+      "ParseTree"   => [:dstr, "before [",
+                        [:evstr, [:vcall, :nest]], [:str, "] after"]],
+      "Ruby2Ruby"   => "\"before [#\{nest}] after\"",
+    },
+
+    "dstr_str_lit_start" => {
+      "Ruby"        => '"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"',
+      "ParseTree"   => [:dstr,
+                        "blah(string):",
+                        [:evstr, [:lit, 1]],
+                        [:str, ": warning: "],
+                        [:evstr, [:call, [:gvar, :$!], :message]],
+                        [:str, " ("],
+                        [:evstr, [:call, [:gvar, :$!], :class]],
+                        [:str, ")"]],
+      "Ruby2Ruby"   => '"blah(string):#{1}: warning: #{$!.message} (#{$!.class})"',
+    },
+
+    "dstr_the_revenge"  => {
+      "Ruby"        => '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"',
+      "ParseTree"   => [:dstr,
+                        "before ",
+                        [:evstr, [:vcall, :from]],
+                        [:str, " middle "],
+                        [:evstr, [:vcall, :to]],
+                        [:str, " ("],
+                        [:str, "(string)"],
+                        [:str, ":"],
+                        [:evstr, [:lit, 1]],
+                        [:str, ")"]],
+      "Ruby2Ruby"   => '"before #{from} middle #{to} ((string):#{1})"',
+    },
+
     "dsym"  => {
       "Ruby"        => ":\"x#\{(1 + 1)}y\"",
       "ParseTree"   => [:dsym, "x",
-                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], [:str, "y"]],
+                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]], [:str, "y"]],
     },
 
     "dxstr" => {
       "Ruby"        => "t = 5\n`touch #\{t}`\n",
       "ParseTree"   => [:block,
                         [:lasgn, :t, [:lit, 5]],
-                        [:dxstr, 'touch ', [:lvar, :t]]],
+                        [:dxstr, 'touch ', [:evstr, [:lvar, :t]]]],
     },
 
     "ensure" => {
-      "Ruby"        => "begin
-  (1 + 1)
-rescue SyntaxError => e1
-  2
-rescue Exception => e2
-  3
-else
-  4
-ensure
-  5
+      "Ruby"        => "begin\n  (1 + 1)\nrescue SyntaxError => e1\n  2\nrescue Exception => e2\n  3\nelse\n  4\nensure\n  5
 end",
       "ParseTree"   => [:begin,
                         [:ensure,
@@ -644,9 +1167,46 @@ end",
       "Ruby2Ruby" => "def an_alias(x)\n  (x + 1)\nend"
     },
 
-    "fcall"  => {
-      "Ruby"        => "p(4)",
-      "ParseTree"   => [:fcall, :p, [:array, [:lit, 4]]],
+    "fcall_arglist"  => {
+      "Ruby"        => "m(42)",
+      "ParseTree"   => [:fcall, :m, [:array, [:lit, 42]]],
+    },
+
+    "fcall_arglist_hash"  => {
+      "Ruby"        => "m(:a => 1, :b => 2)",
+      "ParseTree"   => [:fcall, :m,
+                        [:array,
+                         [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]],
+    },
+
+    "fcall_arglist_norm_hash"  => {
+      "Ruby"        => "m(42, :a => 1, :b => 2)",
+      "ParseTree"   => [:fcall, :m,
+                        [:array,
+                         [:lit, 42],
+                         [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]],
+    },
+
+    "fcall_arglist_norm_hash_splat"  => {
+      "Ruby"        => "m(42, :a => 1, :b => 2, *c)",
+      "ParseTree"   => [:fcall, :m,
+                        [:argscat,
+                         [:array,
+                          [:lit, 42],
+                          [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]],
+                         [:vcall, :c]]],
+    },
+
+    "fcall_block"  => {
+      "Ruby"        => "a(:b) { :c }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a, [:array, [:lit, :b]]], nil,
+                        [:lit, :c]],
+    },
+
+    "fcall_keyword"  => {
+      "Ruby"        => "42 if block_given?",
+      "ParseTree"   => [:if, [:fcall, :block_given?], [:lit, 42], nil],
     },
 
     "flip2"  => {
@@ -667,6 +1227,18 @@ end",
                          [:nil]]],
     },
 
+    "flip2_method"  => {
+      "Ruby"        => "if 1..2.a?(b) then
+  nil
+end",
+      "ParseTree"   => [:if,
+                        [:flip2,
+                         [:lit, 1],
+                         [:call, [:lit, 2], :a?, [:array, [:vcall, :b]]]],
+                        [:nil],
+                        nil],
+    },
+
     "flip3"  => {
       "Ruby"        => "x = if ((i % 4) == 0)...((i % 3) == 0) then\n  i\nelse\n  nil\nend",
       "ParseTree"   => [:lasgn,
@@ -686,11 +1258,20 @@ end",
     },
 
     "for"  => {
-      "Ruby"        => "for o in ary\n  puts(o)\nend\n",
-      "ParseTree"   => [:for, [:vcall, :ary], [:lasgn, :o],
+      "Ruby"        => "for o in ary do\n  puts(o)\nend",
+      "ParseTree"   => [:for,
+                        [:vcall, :ary],
+                        [:lasgn, :o],
                         [:fcall, :puts, [:array, [:lvar, :o]]]],
     },
 
+    "for_no_body"  => {
+      "Ruby"        => "for i in (0..max) do\n  # do nothing\nend",
+      "ParseTree"   => [:for,
+                        [:dot2, [:lit, 0], [:vcall, :max]],
+                        [:lasgn, :i]],
+    },
+
     "gasgn"  => {
       "Ruby"        => "$x = 42",
       "ParseTree"   => [:gasgn, :$x, [:lit, 42]],
@@ -706,6 +1287,16 @@ end",
       "ParseTree"   => [:gvar, :$x],
     },
 
+    "gvar_underscore"  => {
+      "Ruby"        => "$_",
+      "ParseTree"   => [:gvar, :$_],
+    },
+
+    "gvar_underscore_blah"  => {
+      "Ruby"        => "$__blah",
+      "ParseTree"   => [:gvar, :$__blah],
+    },
+
     "hash"  => {
       "Ruby"        => "{ 1 => 2, 3 => 4 }",
       "ParseTree"   => [:hash, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]],
@@ -814,6 +1405,78 @@ end",
                           [:array, [:call, [:dvar, :y], :to_s]]]]]]],
     },
 
+    "iteration7" => {
+      "Ruby"        => "a { |b, c| p(c) }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        [:masgn,
+                         [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]]],
+                        [:fcall, :p, [:array, [:dvar, :c]]]],
+    },
+
+    "iteration8" => {
+      "Ruby"        => "a { |b, c, *d| p(c) }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        [:masgn,
+                         [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]],
+                         [:dasgn_curr, :d]],
+                        [:fcall, :p, [:array, [:dvar, :c]]]],
+    },
+
+    "iteration9" => {
+      "Ruby"        => "a { |b, c, *| p(c) }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        [:masgn,
+                         [:array, [:dasgn_curr, :b], [:dasgn_curr, :c]],
+                         [:splat]],
+                        [:fcall, :p, [:array, [:dvar, :c]]]],
+    },
+
+    "iteration9" => {
+      "Ruby"        => "a { |*| p(c) }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        [:masgn,
+                         [:splat]],
+                        [:fcall, :p, [:array, [:vcall, :c]]]],
+    },
+
+    "iteration_dasgn_curr_dasgn_madness"  => {
+      "Ruby"        => "as.each { |a|\n  b += a.b(false) }",
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :as], :each],
+                        [:dasgn_curr, :a],
+                        [:dasgn_curr,
+                         :b,
+                         [:call,
+                          [:dvar, :b],
+                          :+,
+                          [:array,
+                           [:call, [:dvar, :a], :b, [:array, [:false]]]]]]],
+      "Ruby2Ruby"   => "as.each { |a| b = (b + a.b(false)) }",
+    },
+
+    "iteration_double_var" => {
+      "Ruby"        => "a do |x|\n  b do |x| \n    puts x\n  end\nend",
+      "ParseTree"   => [:iter,
+                        [:fcall, :a],
+                        [:dasgn_curr, :x],
+                        [:iter,
+                         [:fcall, :b],
+                         [:dasgn, :x],
+                         [:fcall, :puts, [:array, [:dvar, :x]]]]],
+      "Ruby2Ruby"   => "a { |x| b { |x| puts(x) } }",
+    },
+
+    "iteration_masgn"  => {
+      "Ruby"        => "define_method(method) { |*args| }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :define_method, [:array, [:vcall, :method]]],
+                        [:masgn, [:dasgn_curr, :args]]],
+    },
+
     "ivar" => {
       "Ruby"        => [Examples, :reader],
       "ParseTree"   => [:defn, :reader, [:ivar, :@reader]],
@@ -822,9 +1485,10 @@ end",
 
     "lasgn_array" => {
       "Ruby"        => "var = [\"foo\", \"bar\"]",
-      "ParseTree"   => [:lasgn, :var, [:array,
-                                       [:str, "foo"],
-                                       [:str, "bar"]]],
+      "ParseTree"   => [:lasgn, :var,
+                        [:array,
+                         [:str, "foo"],
+                         [:str, "bar"]]],
     },
 
     "lasgn_call" => {
@@ -852,6 +1516,11 @@ end",
       "ParseTree"   => [:lit, 1],
     },
 
+    "lit_long_negative" => {
+      "Ruby"        => "-1",
+      "ParseTree"   => [:lit, -1],
+    },
+
     "lit_range2" => {
       "Ruby"        => "(1..10)",
       "ParseTree"   => [:lit, 1..10],
@@ -867,9 +1536,20 @@ end",
       "ParseTree"   => [:lit, /x/],
     },
 
-    "lit_str" => {
-      "Ruby"        => "\"x\"",
-      "ParseTree"   => [:str, "x"],
+    "lit_regexp_i_wwtt"  => {
+      "Ruby"        => 'str.split(//i)',
+      "ParseTree"   => [:call, [:vcall, :str], :split, [:array, [:lit, //i]]],
+    },
+    
+    "lit_regexp_n" => {
+      "Ruby"        => "/x/n",
+      "ParseTree"   => [:lit, /x/n],
+    },
+
+    "lit_regexp_once" => {
+      "Ruby"        => "/x/o",
+      "ParseTree"   => [:lit, /x/],
+      "Ruby2Ruby"   => "/x/",
     },
 
     "lit_sym" => {
@@ -877,6 +1557,32 @@ end",
       "ParseTree"   => [:lit, :x],
     },
 
+    "lit_sym_splat" => {
+      "Ruby"        => ":\"*args\"",
+      "ParseTree"   => [:lit, :"*args"],
+    },
+
+    "lvar_def_boundary" => { # HACK: put # do nothing back under begin
+      "Ruby"        => "b = 42\ndef a\n  c do\n    begin\n    rescue RuntimeError => b\n      puts(b)\n    end\n  end\nend\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :b, [:lit, 42]],
+                        [:defn,
+                         :a,
+                         [:scope,
+                          [:block,
+                           [:args],
+                           [:iter,
+                            [:fcall, :c],
+                            nil,
+                            [:begin,
+                             [:rescue,
+                              [:resbody,
+                               [:array, [:const, :RuntimeError]],
+                               [:block,
+                                [:dasgn_curr, :b, [:gvar, :$!]],
+                                [:fcall, :puts, [:array, [:dvar, :b]]]]]]]]]]]],
+    },
+
     "masgn"  => {
       "Ruby"        => "a, b = c, d",
       "ParseTree"   => [:masgn,
@@ -891,7 +1597,7 @@ end",
                         [:lasgn, :c],
                         [:argscat,
                          [:array, [:lit, 1], [:lit, 2]],
-                         [:array, [:lit, 3], [:lit, 4]]]]
+                         [:array, [:lit, 3], [:lit, 4]]]],
     },
 
     "masgn_attrasgn"  => {
@@ -936,6 +1642,39 @@ end",
                          [:vcall, :f], [:vcall, :g]]]
     },
 
+    "masgn_splat_no_name_to_ary"  => {
+      "Ruby"        => "a, b, * = c",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:splat],
+                        [:to_ary, [:vcall, :c]]],
+    },
+
+    "masgn_splat_no_name_trailing"  => {
+      "Ruby"        => "a, b, = c",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:to_ary, [:vcall, :c]]],
+      "Ruby2Ruby"   => "a, b = c", # TODO: check this is right
+    },
+
+    "masgn_splat_to_ary"  => {
+      "Ruby"        => "a, b, *c = d",
+      "ParseTree"   => [:masgn,
+                         [:array, [:lasgn, :a], [:lasgn, :b]],
+                         [:lasgn, :c],
+                         [:to_ary, [:vcall, :d]]],
+    },
+
+    "masgn_splat_to_ary2"  => {
+      "Ruby"        => "a, b, *c = d.e(\"f\")",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:lasgn, :c],
+                        [:to_ary,
+                         [:call, [:vcall, :d], :e, [:array, [:str, 'f']]]]],
+    },
+
     "match"  => {
       "Ruby"        => "1 if /x/",
       "ParseTree"   => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
@@ -966,6 +1705,14 @@ end",
                         [:if, [:false], [:next], nil]],
     },
 
+    "next_arg"  => {
+      "Ruby"        => "loop { next 42 if false }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :loop],
+                        nil,
+                        [:if, [:false], [:next, [:lit, 42]], nil]],
+    },
+
     "not"  => {
       "Ruby"        => "(not true)",
       "ParseTree"   => [:not, [:true]],
@@ -1009,6 +1756,11 @@ end",
                          [:lit, 42]]],
     },
 
+    "op_asgn2_self"  => {
+      "Ruby"        => "self.Bag ||= Bag.new",
+      "ParseTree"   => [:op_asgn2, [:self], :"Bag=", :"||", [:call, [:const, :Bag], :new]],
+    },
+
     "op_asgn_and" => {
       "Ruby"        => "a = 0\na &&= 2\n",
       "ParseTree"   => [:block,
@@ -1016,6 +1768,21 @@ end",
                         [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]],
     },
 
+    "op_asgn_and_ivar2" => { # eww... stupid rubygems
+      "Ruby"        => "@fetcher &&= new(Gem.configuration[:http_proxy])",
+      "ParseTree"   => [:op_asgn_and,
+                        [:ivar, :@fetcher],
+                        [:iasgn,
+                         :@fetcher,
+                         [:fcall,
+                          :new,
+                          [:array,
+                           [:call,
+                            [:call, [:const, :Gem], :configuration],
+                            :[],
+                            [:array, [:lit, :http_proxy]]]]]]],
+    },
+
     "op_asgn_or" => {
       "Ruby"        => "a = 0\na ||= 1\n",
       "ParseTree"   => [:block,
@@ -1023,11 +1790,57 @@ end",
                         [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]],
     },
 
+    "op_asgn_or_block"  => {
+      "Ruby"        => "a ||= begin\n        b\n      rescue\n        c\n      end",
+      "ParseTree"   => [:op_asgn_or,
+                        [:lvar, :a],
+                        [:lasgn, :a,
+                         [:rescue,
+                          [:vcall, :b],
+                          [:resbody, nil, [:vcall, :c]]]]],
+      "Ruby2Ruby"   => "a ||= b rescue c",
+    },
+
+    "op_asgn_or_ivar" => {
+      "Ruby"        => "@v ||= {  }",
+      "ParseTree"   => [:op_asgn_or, [:ivar, :@v], [:iasgn, :@v, [:hash]]],
+    },
+
+    "op_asgn_or_ivar2" => { # eww... stupid rubygems
+      "Ruby"        => "@fetcher ||= new(Gem.configuration[:http_proxy])",
+      "ParseTree"   => [:op_asgn_or,
+                        [:ivar, :@fetcher],
+                        [:iasgn,
+                         :@fetcher,
+                         [:fcall,
+                          :new,
+                          [:array,
+                           [:call,
+                            [:call, [:const, :Gem], :configuration],
+                            :[],
+                            [:array, [:lit, :http_proxy]]]]]]],
+    },
+
     "or"  => {
       "Ruby"        => "(a or b)",
       "ParseTree"   => [:or, [:vcall, :a], [:vcall, :b]],
     },
 
+    "or_big"  => {
+      "Ruby"        => "((a or b) or (c and d))",
+      "ParseTree"   => [:or,
+                        [:or,  [:vcall, :a], [:vcall, :b]],
+                        [:and, [:vcall, :c], [:vcall, :d]]],
+    },
+
+    "or_big2"  => {
+      "Ruby"        => "((a || b) || (c && d))",
+      "ParseTree"   => [:or,
+                        [:or,  [:vcall, :a], [:vcall, :b]],
+                        [:and, [:vcall, :c], [:vcall, :d]]],
+      "Ruby2Ruby"   => "((a or b) or (c and d))",
+    },
+
     "postexe"  => {
       "Ruby"        => "END { 1 }",
       "ParseTree"   => [:iter, [:postexe], nil, [:lit, 1]],
@@ -1049,6 +1862,14 @@ end",
                       [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
     },
 
+    "proc_zero_args" => {
+      "Ruby" => "proc { || (x + 1) }",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      0,
+                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+    },
+
     "redo"  => {
       "Ruby"        => "loop { redo if false }",
       "ParseTree"   => [:iter,
@@ -1061,11 +1882,15 @@ end",
     },
 
     "rescue_block_body"  => {
-      "Ruby"        => "begin\n  blah\nrescue\n  42\nend",
+      "Ruby"        => "begin\n  a\nrescue => e\n  c\n  d\nend",
       "ParseTree"   => [:begin,
                         [:rescue,
-                         [:vcall, :blah],
-                         [:resbody, nil, [:lit, 42]]]],
+                         [:vcall, :a],
+                         [:resbody, nil,
+                          [:block,
+                           [:lasgn, :e, [:gvar, :$!]],
+                           [:vcall, :c],
+                           [:vcall, :d]]]]],
     },
 
     "rescue_block_nada"  => {
@@ -1088,11 +1913,36 @@ end",
       "ParseTree"   => [:retry],
     },
 
+    "return_0"  => {
+      "Ruby"        => "return",
+      "ParseTree"   => [:return],
+    },
+
+    "return_1"  => {
+      "Ruby"        => "return 1",
+      "ParseTree"   => [:return, [:lit, 1]],
+    },
+
+    "return_n"  => {
+      "Ruby"        => "return 1, 2, 3",
+      "ParseTree"   => [:return, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
+      "Ruby2Ruby"   => "return [1, 2, 3]",
+    },
+
     "sclass"  => {
       "Ruby"        => "class << self\n  42\nend",
       "ParseTree"   => [:sclass, [:self], [:scope, [:lit, 42]]],
     },
 
+    "sclass_trailing_class" => {
+      "Ruby" => "class A\n  class << self\n    a\n  end\n  class B\n  end\nend",
+      "ParseTree" => [:class, :A, nil,
+                      [:scope,
+                       [:block,
+                        [:sclass, [:self], [:scope, [:vcall, :a]]],
+                        [:class, :B, nil, [:scope]]]]],
+    },
+
     "splat"  => {
       "Ruby"        => "def x(*b)\n  a(*b)\nend",
       "ParseTree"   => [:defn, :x,
@@ -1102,6 +1952,125 @@ end",
                           [:fcall, :a, [:splat, [:lvar, :b]]]]]],
     },
 
+    "str" => {
+      "Ruby"        => '"x"',
+      "ParseTree"   => [:str, "x"],
+    },
+
+    "str_concat_newline" => {
+      "Ruby"        => '"before" \\
+  " after"',
+      "ParseTree"   => [:str, "before after"],
+      "Ruby2Ruby"   => '"before after"',
+    },
+
+    "str_concat_space" => {
+      "Ruby"        => '"before" " after"',
+      "ParseTree"   => [:str, "before after"],
+      "Ruby2Ruby"   => '"before after"',
+    },
+
+    "str_heredoc" => {
+      "Ruby"        => "<<'EOM'\n  blah\nblah\nEOM\n",
+      "ParseTree"   => [:str, "  blah\nblah\n"],
+      "Ruby2Ruby"   => "\"  blah\\nblah\\n\"",
+    },
+
+    "str_heredoc_call" => {
+      "Ruby"        => "<<'EOM'.strip\n  blah\nblah\nEOM\n",
+      "ParseTree"   => [:call, [:str, "  blah\nblah\n"], :strip],
+      "Ruby2Ruby"   => "\"  blah\\nblah\\n\".strip",
+    },
+
+    "str_heredoc_double" => {
+      "Ruby"       => "a += <<-BEGIN + b + <<-END\n  first\nBEGIN\n  second\nEND",
+      "ParseTree"  => [:lasgn, :a,
+                       [:call,
+                        [:lvar, :a],
+                        :+,
+                        [:array,
+                         [:call,
+                          [:call, [:str, "  first\n"], :+,
+                           [:array, [:vcall, :b]]],
+                          :+,
+                          [:array, [:str, "  second\n"]]]]]],
+      "Ruby2Ruby"   => "a = (a + ((\"  first\\n\" + b) + \"  second\\n\"))",
+    },
+
+    "dstr_heredoc_expand" => {
+      "Ruby"        => "<<EOM\n  blah\n#\{1 + 1}blah\nEOM\n",
+      "ParseTree"   => [:dstr, "  blah\n",
+                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
+                        [:str, "blah\n"]],
+      "Ruby2Ruby"   => "\"  blah\\n#\{(1 + 1)}blah\\n\"",
+    },
+
+    "str_heredoc_indent" => {
+      "Ruby"        => "<<-EOM\n  blah\nblah\n\n  EOM\n",
+      "ParseTree"   => [:str, "  blah\nblah\n\n"],
+      "Ruby2Ruby"   => "\"  blah\\nblah\\n\\n\"",
+    },
+
+    "dstr_heredoc_windoze_sucks" => {
+      "Ruby"        => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n  EOF\r\n",
+      "ParseTree"   => [:dstr,
+                        'def test_',
+                        [:evstr, [:vcall, :action]],
+                        [:str, "_valid_feed\n"]],
+      "Ruby2Ruby"   => "\"def test_#\{action}_valid_feed\\n\"",
+    },
+
+    "str_interp_file" => {
+      "Ruby"        => '"file = #{__FILE__}
+"',
+      "ParseTree"   => [:str, "file = (string)\n"],
+      "Ruby2Ruby"   => '"file = (string)\\n"',
+    },
+
+    "structure_extra_block_for_dvar_scoping"  => {
+      "Ruby"        => "a.b do |c, d|\n  unless e.f(c) then\n    g = false\n    d.h { |x, i| g = true }\n  \n  end\nend", # FIX: don't like the extra return
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :a], :b],
+                        [:masgn, [:array, [:dasgn_curr, :c], [:dasgn_curr, :d]]],
+                        [:block,
+                         [:dasgn_curr, :g],
+                         [: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]]],
+                            [:dasgn, :g, [:true]]]]]]],
+      },
+
+    "structure_remove_begin_1"  => {
+      "Ruby"        => "a << begin\n       b\n     rescue\n       c\n     end",
+      "ParseTree"   => [:call, [:vcall, :a], :<<,
+                        [:array, [:rescue, [:vcall, :b],
+                                  [:resbody, nil, [:vcall, :c]]]]],
+      "Ruby2Ruby"   => "(a << b rescue c)",
+    },
+
+    "structure_remove_begin_2"  => {
+      "Ruby"        => "a = if c\n      begin\n        b\n      rescue\n        nil\n      end\n    end\na",
+      "ParseTree"   => [:block,
+                        [:lasgn,
+                         :a,
+                         [:if, [:vcall, :c],
+                          [:rescue, [:vcall, :b], [:resbody, nil, [:nil]]],
+                          nil]],
+                        [:lvar, :a]],
+      "Ruby2Ruby"   => "a = b rescue nil if c\na\n", # OMG that's awesome
+    },
+
+    "structure_unused_literal_wwtt"  => {
+      "Ruby"        => "\"prevent the above from infecting rdoc\"\n\nmodule Graffle\nend",
+      "ParseTree"   => [:module, :Graffle, [:scope]],
+      "Ruby2Ruby"   => "module Graffle\nend",
+    },
+
     # TODO: all supers need to pass args
     "super"  => {
       "Ruby"        => "def x\n  super(4)\nend",
@@ -1112,6 +2081,20 @@ end",
                           [:super, [:array, [:lit, 4]]]]]],
     },
 
+    "super_block_pass"  => {
+      "Ruby"        => "super(a, &b)",
+      "ParseTree"   => [:block_pass,
+                        [:vcall, :b], [:super, [:array, [:vcall, :a]]]],
+    },
+
+    "super_block_splat"  => {
+      "Ruby"        => "super(a, *b)",
+      "ParseTree"   => [:super,
+                        [:argscat,
+                         [:array, [:vcall, :a]],
+                         [:vcall, :b]]],
+    },
+
     "super_multi"  => {
       "Ruby"        => "def x\n  super(4, 2, 1)\nend",
       "ParseTree"   => [:defn, :x,
@@ -1143,7 +2126,15 @@ end",
       "ParseTree"   => [:undef, [:lit, :x]],
     },
 
-    "undef_multi"  => {
+    "undef_2"  => {
+      "Ruby"        => "undef :x, :y",
+      "ParseTree"   => [:block,
+                        [:undef, [:lit, :x]],
+                        [:undef, [:lit, :y]]],
+      "Ruby2Ruby"   => "undef :x\nundef :y\n",
+    },
+
+    "undef_3"  => {
       "Ruby"        => "undef :x, :y, :z",
       "ParseTree"   => [:block,
                         [:undef, [:lit, :x]],
@@ -1152,18 +2143,98 @@ end",
       "Ruby2Ruby"   => "undef :x\nundef :y\nundef :z\n",
     },
 
+    "undef_block_1"  => {
+      "Ruby"        => "f1\nundef :x\n", # TODO: don't like the extra return
+      "ParseTree"   => [:block,
+                        [:vcall, :f1],
+                        [:undef, [:lit, :x]]],
+    },
+
+    "undef_block_2"  => {
+      "Ruby"        => "f1\nundef :x, :y",
+      "ParseTree"   => [:block,
+                        [:vcall, :f1],
+                        [:block,
+                         [:undef, [:lit, :x]],
+                         [:undef, [:lit, :y]],
+                        ]],
+      "Ruby2Ruby"   => "f1\n(undef :x\nundef :y)\n",
+    },
+
+    "undef_block_3"  => {
+      "Ruby"        => "f1\nundef :x, :y, :z",
+      "ParseTree"   => [:block,
+                        [:vcall, :f1],
+                        [:block,
+                         [:undef, [:lit, :x]],
+                         [:undef, [:lit, :y]],
+                         [:undef, [:lit, :z]],
+                        ]],
+      "Ruby2Ruby"   => "f1\n(undef :x\nundef :y\nundef :z)\n",
+    },
+
+    "undef_block_3_post"  => {
+      "Ruby"        => "undef :x, :y, :z\nf2",
+      "ParseTree"   => [:block,
+                        [:undef, [:lit, :x]],
+                        [:undef, [:lit, :y]],
+                        [:undef, [:lit, :z]],
+                        [:vcall, :f2]],
+      "Ruby2Ruby"   => "undef :x\nundef :y\nundef :z\nf2\n",
+    },
+
+    "undef_block_wtf"  => {
+      "Ruby"        => "f1\nundef :x, :y, :z\nf2",
+      "ParseTree"   => [:block,
+                        [:vcall, :f1],
+                        [:block,
+                         [:undef, [:lit, :x]],
+                         [:undef, [:lit, :y]],
+                         [:undef, [:lit, :z]]],
+                        [:vcall, :f2]],
+      "Ruby2Ruby"   => "f1\n(undef :x\nundef :y\nundef :z)\nf2\n",
+    },
+
     "until_post"  => {
       "Ruby"        => "begin\n  (1 + 1)\nend until false",
       "ParseTree"   => [:until, [:false],
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
     },
 
+    "until_post_not"  => {
+      "Ruby"        => "begin\n  (1 + 1)\nend until not true",
+      "ParseTree"   => [:while, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+      "Ruby2Ruby"   => "begin\n  (1 + 1)\nend while true",
+    },
+
     "until_pre"  => {
       "Ruby"        => "until false do\n  (1 + 1)\nend",
       "ParseTree"   => [:until, [:false],
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
     },
 
+    "until_pre_mod"  => {
+      "Ruby"        => "(1 + 1) until false",
+      "ParseTree"   => [:until, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "until false do\n  (1 + 1)\nend",
+    },
+
+    "until_pre_not"  => {
+      "Ruby"        => "until not true do\n  (1 + 1)\nend",
+      "ParseTree"   => [:while, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "while true do\n  (1 + 1)\nend",
+    },
+
+    "until_pre_not_mod"  => {
+      "Ruby"        => "(1 + 1) until not true",
+      "ParseTree"   => [:while, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "while true do\n  (1 + 1)\nend",
+    },
+
     "valias"  => {
       "Ruby"        => "alias $y $x",
       "ParseTree"   => [:valias, :$y, :$x],
@@ -1180,17 +2251,45 @@ end",
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
     },
 
+    "while_post_not" => {
+      "Ruby"        => "begin\n  (1 + 1)\nend while not true",
+      "ParseTree"   => [:until, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+      "Ruby2Ruby"   => "begin\n  (1 + 1)\nend until true",
+    },
+
     "while_pre" => {
       "Ruby"        => "while false do\n  (1 + 1)\nend",
       "ParseTree"   => [:while, [:false],
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
     },
 
+    "while_pre_mod"  => {
+      "Ruby"        => "(1 + 1) while false",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "while false do\n  (1 + 1)\nend", # FIX can be one liner
+    },
+
     "while_pre_nil" => {
       "Ruby"        => "while false do\nend",
       "ParseTree"   => [:while, [:false], nil, true],
     },
 
+    "while_pre_not" => {
+      "Ruby"        => "while not true do\n  (1 + 1)\nend",
+      "ParseTree"   => [:until, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "until true do\n  (1 + 1)\nend",
+    },
+
+    "while_pre_not_mod"  => {
+      "Ruby"        => "(1 + 1) while not true",
+      "ParseTree"   => [:until, [:true],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+      "Ruby2Ruby"   => "until true do\n  (1 + 1)\nend", # FIX
+    },
+
     "xstr" => {
       "Ruby"        => "`touch 5`",
       "ParseTree"   => [:xstr, 'touch 5'],
@@ -1222,35 +2321,6 @@ end",
     },
   }
 
-#   def test_audit_nodes
-#     # TODO: audit @@testcases.keys against node list - do two way audit, rename everything
-#     nodes = ParseTree::NODE_NAMES.map { |s| s.to_s }.sort
-#     tested = @@testcases.keys.map { |s| s.to_s }.sort
-#     if processor.respond_to? :unsupported then
-#       nodes -= processor.unsupported
-#     else
-#       SexpProcessor.new.unsupported
-#       # HACK
-#       nodes -= [:alloca, :argspush, :cfunc, :cref, :evstr, :ifunc, :last, :memo, :newline, :opt_n, :method].map { |s| s.to_s }
-#     end
-
-#     untested = nodes-tested
-
-#     puts
-#     p :untested_nodes => untested, :extra_nodes => tested-nodes
-
-#     untested.each do |node|
-#       puts %(
-#     "#{node}"  => {
-#       "Ruby"        => "XXX",
-#       "ParseTree"   => [],
-#     },
-# )
-#     end
-
-#     flunk
-#   end
-
   def self.previous(key, extra=0)
     idx = @@testcase_order.index(key)-1-extra
     case key
@@ -1260,18 +2330,6 @@ end",
     @@testcase_order[idx]
   end
 
-#   # lets us used unprocessed :self outside of tests, called when subclassed
-#   def self.clone_same
-#     @@testcases.each do |node, data|
-#       data.each do |key, val|
-#         if val == :same then
-#           prev_key = self.previous(key)
-#           data[key] = data[prev_key].deep_clone
-#         end
-#       end
-#     end
-#   end
-
   def self.inherited(c)
     output_name = c.name.to_s.sub(/^Test/, '')
     raise "Unknown class #{c} in @@testcase_order" unless
@@ -1322,5 +2380,5 @@ end",
     end
   end
 
-  undef_method :default_test
+  undef_method :default_test rescue nil
 end