rubyjs 0.7.0

data/vendor/ParseTree-1.7.1/lib/unique.rb

@@ -0,0 +1,15 @@
+##
+# Unique creates unique variable names.
+
+class Unique
+  def self.reset # mostly for testing
+    @@curr = 0
+  end
+
+  def self.next
+    @@curr += 1
+    "temp_#{@@curr}".intern
+  end
+
+  reset
+end

data/vendor/ParseTree-1.7.1/test/pt_testcase.rb

@@ -0,0 +1,1221 @@
+require 'test/unit/testcase'
+require 'sexp_processor' # for deep_clone
+require 'unique'
+
+class Examples
+  attr_reader :reader
+  attr_writer :writer
+
+  def a_method(x); x+1; end
+  alias an_alias a_method
+
+  define_method(:unsplatted) do |x|
+    x + 1
+  end
+
+  define_method :splatted do |*args|
+    y = args.first
+    y + 42
+  end
+
+  define_method :dmethod_added, instance_method(:a_method) if RUBY_VERSION < "1.9"
+end
+
+class ParseTreeTestCase < Test::Unit::TestCase
+
+  attr_accessor :processor # to be defined by subclass
+
+  def self.testcase_order; @@testcase_order; end
+  def self.testcases; @@testcases; end
+
+  def setup
+    super
+    @processor = nil
+    Unique.reset
+  end
+
+  def self.add_test name, data, klass = self.name[4..-1]
+    name = name.to_s
+    klass = klass.to_s
+    if testcases.has_key? name then
+      if testcases[name].has_key? klass then
+        warn "testcase #{klass}##{name} already has data"
+      else
+        testcases[name][klass] = data
+      end
+    else
+      warn "testcase #{name} does not exist"
+    end
+  end
+
+  def self.unsupported_tests *tests
+    tests.flatten.each do |name|
+      add_test name, :unsupported
+    end
+  end
+
+  @@testcase_order = %w(Ruby ParseTree)
+
+  @@testcases = {
+
+    "alias"  => {
+      "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"  => {
+      "Ruby"        => "a = b, c, *d",
+      "ParseTree"   => [:lasgn, :a,
+                        [:svalue,
+                         [:argscat,
+                          [:array, [:vcall, :b], [:vcall, :c]],
+                          [:vcall, :d]]]],
+    },
+
+    "argspush"  => {
+      "Ruby"        => "a[*b] = c",
+      "ParseTree"   => [:attrasgn,
+                        [:vcall, :a],
+                        :[]=,
+                        [:argspush, [:splat, [:vcall, :b]], [:vcall, :c]]],
+    },
+
+    "array"  => {
+      "Ruby"        => "[1, :b, \"c\"]",
+      "ParseTree"   => [:array, [:lit, 1], [:lit, :b], [:str, "c"]],
+    },
+
+    "attrasgn" => {
+      "Ruby"        => "y = 0\n42.method = y\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :y, [:lit, 0]],
+                        [:attrasgn, [:lit, 42], :method=, [:array, [:lvar, :y]]]],
+    },
+
+    "attrasgn_index_equals" => {
+      "Ruby"        => "a[42] = 24",
+      "ParseTree"   => [:attrasgn, [:vcall, :a], :[]=, [:array, [:lit, 42], [:lit, 24]]],
+    },
+
+    "attrset" => {
+      "Ruby"        => [Examples, :writer=],
+      "ParseTree"   => [:defn, :writer=, [:attrset, :@writer]],
+      "Ruby2Ruby"   => "attr_writer :writer"
+    },
+
+    "back_ref"  => {
+      "Ruby"        => "[$&, $`, $', $+]",
+      "ParseTree"   => [:array,
+                        [:back_ref, :&],
+                        [:back_ref, "`".intern], # symbol was fucking up emacs
+                        [:back_ref, "'".intern], # s->e
+                        [:back_ref, :+]],
+    },
+
+    "begin"  => {
+      "Ruby"        => "begin\n  (1 + 1)\nend",
+      "ParseTree"   => [:begin, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
+    },
+
+    "begin_rescue_ensure" => {
+      "Ruby" => "begin\n    rescue\n      # do nothing\n  ensure\n    nil\nend",
+      "ParseTree" => [:begin,
+                       [:ensure,
+                         [:rescue,
+                           [:resbody, nil]],
+                           [:nil]]]
+    },
+
+    "block_pass"  => {
+      "Ruby"        => "a(&b)",
+      "ParseTree"   => [:block_pass, [:vcall, :b], [:fcall, :a]],
+    },
+
+    "block_pass_omgwtf" => {
+      "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
+      "ParseTree" => [:block_pass,
+                      [:iter,
+                       [:call, [:const, :Proc], :new],
+                       [:masgn, [:dasgn_curr, :args]],
+                       [:nil]],
+                      [:fcall, :define_attr_method,
+                       [:array, [:lit, :x], [:lit, :sequence_name]]]],
+    },
+
+    "block_pass_splat" => {
+      "Ruby" => "def blah(*args, &block)\n  other(*args, &block)\nend",
+      "ParseTree" => [:defn, :blah,
+                      [:scope,
+                       [:block,
+                        [:args, "*args".intern],
+                        [:block_arg, :block],
+                        [:block_pass,
+                         [:lvar, :block],
+                         [:fcall, :other, [:splat, [:lvar, :args]]]]]]],
+    },
+
+    "block_pass_args_and_splat" => {
+      "Ruby" => "def blah(*args, &block)\n  other(42, *args, &block)\nend",
+      "ParseTree" => [:defn, :blah,
+                      [:scope,
+                       [:block,
+                        [:args, "*args".intern],
+                        [:block_arg, :block],
+                        [:block_pass,
+                         [:lvar, :block],
+                         [:fcall, :other,
+                          [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]],
+    },
+
+    "bmethod"  => {
+      "Ruby"        => [Examples, :unsplatted],
+      "ParseTree"   => [:defn,
+                        :unsplatted,
+                        [:bmethod,
+                         [:dasgn_curr, :x],
+                         [:call, [:dvar, :x], "+".intern, [:array, [:lit, 1]]]]],
+      "Ruby2Ruby"   => "def unsplatted(x)\n  (x + 1)\nend"
+    },
+
+    "bmethod_splat" => {
+      "Ruby" => [Examples, :splatted],
+      "ParseTree" => [:defn, :splatted,
+                      [:bmethod,
+                       [:masgn, [:dasgn_curr, :args]],
+                       [:block,
+                        [:dasgn_curr, :y, [:call, [:dvar, :args], :first]],
+                        [:call, [:dvar, :y], :+, [:array, [:lit, 42]]]]]],
+      "Ruby2Ruby" => "def splatted(*args)\n  y = args.first\n  (y + 42)\nend",
+    },
+
+    "break"  => {
+      "Ruby"        => "loop { break if true }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :loop], nil, [:if, [:true], [:break], nil]],
+    },
+
+    "break_arg"  => {
+      "Ruby"        => "loop { break 42 if true }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :loop], nil,
+                        [:if, [:true], [:break, [:lit, 42]], nil]],
+    },
+
+    "call" => {
+      "Ruby"        => "self.method",
+      "ParseTree" => [:call, [:self], :method],
+    },
+
+    "call_arglist"  => {
+      "Ruby"        => "puts(42)",
+      "ParseTree"   => [:fcall, :puts, [:array, [:lit, 42]]],
+    },
+
+    "call_index" => { # see attrasgn_index_equals for opposite
+      "Ruby"        => "a[42]",
+      "ParseTree"   => [:call, [:vcall, :a], :[], [:array, [:lit, 42]]],
+    },
+
+    "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,
+                      [:lasgn, :var, [:lit, 2]],
+                      [:lasgn, :result, [:str, ""]],
+                      [:case,
+                       [:lvar, :var],
+                       [:when,
+                        [:array, [:lit, 1]],
+                        [:block,
+                         [:fcall, :puts, [:array, [:str, "something"]]],
+                         [:lasgn, :result, [:str, "red"]]]],
+                       [:when,
+                        [:array, [:lit, 2], [:lit, 3]],
+                        [:lasgn, :result, [:str, "yellow"]]],
+                       [:when, [:array, [:lit, 4]], nil],
+                       [:lasgn, :result, [:str, "green"]]],
+                      [:case,
+                       [:lvar, :result],
+                       [:when, [:array, [:str, "red"]],
+                        [:lasgn, :var, [:lit, 1]]],
+                       [:when, [:array, [:str, "yellow"]],
+                        [:lasgn, :var, [:lit, 2]]],
+                       [:when, [:array, [:str, "green"]],
+                        [:lasgn, :var, [:lit, 3]]],
+                       nil]]
+    },
+
+    "case_nested" => {
+      "Ruby"        => "var1 = 1\nvar2 = 2\nresult = nil\ncase var1\nwhen 1 then\n  case var2\n  when 1 then\n    result = 1\n  when 2 then\n    result = 2\n  else\n    result = 3\n  end\nwhen 2 then\n  case var2\n  when 1 then\n    result = 4\n  when 2 then\n    result = 5\n  else\n    result = 6\n  end\nelse\n  result = 7\nend\n",
+      "ParseTree" => [:block,
+                      [:lasgn, :var1, [:lit, 1]],
+                      [:lasgn, :var2, [:lit, 2]],
+                      [:lasgn, :result, [:nil]],
+                      [:case,
+                       [:lvar, :var1],
+                       [:when, [:array, [:lit, 1]],
+                        [:case,
+                         [:lvar, :var2],
+                         [:when, [:array, [:lit, 1]],
+                          [:lasgn, :result, [:lit, 1]]],
+                         [:when, [:array, [:lit, 2]],
+                          [:lasgn, :result, [:lit, 2]]],
+                         [:lasgn, :result, [:lit, 3]]]],
+                       [:when, [:array, [:lit, 2]],
+                        [:case,
+                         [:lvar, :var2],
+                         [:when, [:array, [:lit, 1]],
+                          [:lasgn, :result, [:lit, 4]]],
+                         [:when, [:array, [:lit, 2]],
+                          [:lasgn, :result, [:lit, 5]]],
+                         [:lasgn, :result, [:lit, 6]]]],
+                       [:lasgn, :result, [:lit, 7]]]]
+    },
+
+    "case_no_expr" => { # TODO: nested
+      "Ruby" => "case\nwhen 1 then\n  :a\nwhen 2 then\n  :b\nelse\n  :c\nend",
+      "ParseTree" => [:case, nil,
+                      [:when,
+                       [:array, [:lit, 1]],
+                       [:lit, :a]],
+                      [:when,
+                       [:array, [:lit, 2]], [:lit, :b]],
+                      [:lit, :c]],
+    },
+
+    "cdecl"  => {
+      "Ruby"        => "X = 42",
+      "ParseTree"   => [:cdecl, :X, [:lit, 42]],
+    },
+
+    "class_plain"  => {
+      "Ruby"        => "class X\n  puts((1 + 1))\n  def blah\n    puts(\"hello\")\n  end\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        nil,
+                        [:scope,
+                         [:block,
+                          [:fcall, :puts, [:array, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]],
+                          [:defn,
+                           :blah,
+                           [:scope,
+                            [:block,
+                             [:args],
+                             [:fcall, :puts, [:array, [:str, "hello"]]]]]]]]],
+    },
+
+    "class_super_object"  => {
+      "Ruby"        => "class X < Object\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:const, :Object],
+                        [:scope]],
+    },
+
+    "class_super_array"  => {
+      "Ruby"        => "class X < Array\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:const, :Array],
+                        [:scope]],
+    },
+
+    "class_super_expr"  => {
+      "Ruby"        => "class X < expr\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:vcall, :expr],
+                        [:scope]],
+    },
+
+    "colon2"  => {
+      "Ruby"        => "X::Y",
+      "ParseTree"   => [:colon2, [:const, :X], :Y],
+    },
+
+    "colon3"  => {
+      "Ruby"        => "::X",
+      "ParseTree"   => [:colon3, :X],
+    },
+
+    "conditional1" => { # TODO: rename
+      "Ruby"        => "return 1 if (42 == 0)",
+      "ParseTree"   => [:if,
+                        [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+                        [:return, [:lit, 1]],
+                        nil],
+    },
+
+    "conditional2" => { # TODO: remove
+      "Ruby"        => "return 2 unless (42 == 0)",
+      "ParseTree"   => [:if,
+                        [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+                        nil,
+                        [:return, [:lit, 2]]],
+    },
+
+    "conditional3" => {
+      "Ruby"        => "if (42 == 0) then\n  return 3\nelse\n  return 4\nend",
+      "ParseTree"   => [:if, [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+                        [:return, [:lit, 3]],
+                        [:return, [:lit, 4]]],
+    },
+
+    "conditional4" => {
+      "Ruby"        => "if (42 == 0) then\n  return 2\nelsif (42 < 0) then\n  return 3\nelse\n  return 4\nend",
+      "ParseTree"   => [:if,
+                        [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+                        [:return, [:lit, 2]],
+                        [:if,
+                         [:call, [:lit, 42], :<, [:array, [:lit, 0]]],
+                         [:return, [:lit, 3]],
+                         [:return, [:lit, 4]]]],
+      "Ruby2Ruby"   => "if (42 == 0) then\n  return 2\nelse\n  if (42 < 0) then\n    return 3\n  else\n    return 4\n  end\nend",
+    },
+
+    "conditional5" => {
+      "Ruby"       => "return if false unless true",
+      "ParseTree"  => [:if, [:true], nil, [:if, [:false], [:return], nil]],
+    },
+
+    "const"  => {
+      "Ruby"        => "X",
+      "ParseTree"   => [:const, :X],
+    },
+
+    "cvar"  => {
+      "Ruby"        => "@@x",
+      "ParseTree"   => [:cvar, :@@x],
+    },
+
+    "cvasgn"  => {
+      "Ruby"        => "def x\n  @@blah = 1\nend",
+      "ParseTree"   => [:defn, :x,
+                        [:scope,
+                         [:block, [:args], [:cvasgn, :@@blah, [:lit, 1]]]]]
+    },
+
+    "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) } }",
+      "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]]]]]],
+    },
+
+    "dasgn_curr" => {
+      "Ruby"        => "data.each do |x, y|\n  a = 1\n  b = a\n  b = a = x\nend",
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :data], :each],
+                        [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
+                        [:block,
+                         [:dasgn_curr, :a, [:lit, 1]],
+                         [:dasgn_curr, :b, [:dvar, :a]],
+                         [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
+    },
+
+    "defined"  => {
+      "Ruby"        => "defined? $x",
+      "ParseTree"   => [:defined, [:gvar, :$x]],
+    },
+
+    "defn_args" => {
+      "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],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :b],
+                          [:lvar, :c], [:lvar, :d]]]]]]
+    },
+
+    "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]]]],
+    },
+
+# TODO:
+#   add_test("defn_optargs",
+#            s(:defn, :x,
+#              s(:args, :a, "*args".intern),
+#              s(:scope,
+#                s(:block,
+#                  s(:call, nil, :p,
+#                    s(:arglist, s(:lvar, :a), s(:lvar, :args)))))))
+
+    "defn_or" => {
+      "Ruby"        => "def |(o)\n  # do nothing\nend",
+      "ParseTree"   => [:defn, :|, [:scope, [:block, [:args, :o], [:nil]]]],
+    },
+
+    "defn_rescue" => {
+      "Ruby" => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend",
+      "ParseTree" => [:defn, :eql?,
+           [:scope,
+            [:block,
+             [:args, :resource],
+             [:rescue,
+              [:call,
+               [:call, [:self], :uuid],
+               :==,
+               [:array, [:call, [:lvar, :resource], :uuid]]],
+              [:resbody, nil, [:false]]]]]],
+    },
+
+    "defn_zarray" => { # tests memory allocation for returns
+      "Ruby"        => "def zarray\n  a = []\n  return a\nend",
+      "ParseTree"   => [:defn, :zarray,
+                        [:scope,
+                         [:block, [:args],
+                          [:lasgn, :a, [:zarray]], [:return, [:lvar, :a]]]]],
+    },
+
+    "defs" => {
+      "Ruby"      => "def self.x(y)\n  (y + 1)\nend",
+      "ParseTree" => [:defs, [:self], :x,
+                      [:scope,
+                       [:block,
+                        [:args, :y],
+                        [:call, [:lvar, :y], :+, [:array, [:lit, 1]]]]]],
+    },
+
+    "dmethod" => {
+      "Ruby"        => [Examples, :dmethod_added],
+      "ParseTree"   => [:defn,
+                        :dmethod_added,
+                        [:dmethod,
+                         :a_method,
+                         [:scope,
+                          [:block,
+                           [:args, :x],
+                           [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
+      "Ruby2Ruby" => "def dmethod_added(x)\n  (x + 1)\nend"
+    },
+
+    "dot2"  => {
+      "Ruby"        => "(a..b)",
+      "ParseTree"   => [:dot2, [:vcall, :a], [:vcall, :b]],
+    },
+
+    "dot3"  => {
+      "Ruby"        => "(a...b)",
+      "ParseTree"   => [:dot3, [:vcall, :a], [:vcall, :b]],
+    },
+
+    "dregx"  => {
+      "Ruby"        => "/x#\{(1 + 1)}y/",
+      "ParseTree"   => [:dregx, "x",
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], [:str, "y"]],
+    },
+
+    "dregx_once"  => {
+      "Ruby"        => "/x#\{(1 + 1)}y/o",
+      "ParseTree"   => [:dregx_once, "x",
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], [:str, "y"]],
+    },
+
+    "dstr" => {
+      "Ruby"        => "argl = 1\n\"x#\{argl}y\"\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :argl, [:lit, 1]],
+                        [:dstr, "x", [:lvar, :argl],
+                         [:str, "y"]]],
+    },
+
+    "dsym"  => {
+      "Ruby"        => ":\"x#\{(1 + 1)}y\"",
+      "ParseTree"   => [:dsym, "x",
+                        [: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]]],
+    },
+
+    "ensure" => {
+      "Ruby"        => "begin
+  (1 + 1)
+rescue SyntaxError => e1
+  2
+rescue Exception => e2
+  3
+else
+  4
+ensure
+  5
+end",
+      "ParseTree"   => [:begin,
+                        [:ensure,
+                         [:rescue,
+                          [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
+                          [:resbody,
+                           [:array, [:const, :SyntaxError]],
+                           [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
+                           [:resbody,
+                            [:array, [:const, :Exception]],
+                            [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+                          [:lit, 4]],
+                         [:lit, 5]]],
+    },
+
+    "false" => {
+      "Ruby"      => "false",
+      "ParseTree" => [:false],
+    },
+
+    "fbody" => {
+      "Ruby"      => [Examples, :an_alias],
+      "ParseTree" => [:defn, :an_alias,
+                      [:fbody,
+                       [:scope,
+                        [:block,
+                         [:args, :x],
+                         [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
+      "Ruby2Ruby" => "def an_alias(x)\n  (x + 1)\nend"
+    },
+
+    "fcall"  => {
+      "Ruby"        => "p(4)",
+      "ParseTree"   => [:fcall, :p, [:array, [:lit, 4]]],
+    },
+
+    "flip2"  => {
+      "Ruby"        => "x = if ((i % 4) == 0)..((i % 3) == 0) then\n  i\nelse\n  nil\nend",
+      "ParseTree"   => [:lasgn,
+                        :x,
+                        [:if,
+                         [:flip2,
+                          [:call,
+                           [:call, [:vcall, :i], :%, [:array, [:lit, 4]]],
+                           :==,
+                           [:array, [:lit, 0]]],
+                          [:call,
+                           [:call, [:vcall, :i], :%, [:array, [:lit, 3]]],
+                           :==,
+                           [:array, [:lit, 0]]]],
+                         [:vcall, :i],
+                         [:nil]]],
+    },
+
+    "flip3"  => {
+      "Ruby"        => "x = if ((i % 4) == 0)...((i % 3) == 0) then\n  i\nelse\n  nil\nend",
+      "ParseTree"   => [:lasgn,
+                        :x,
+                        [:if,
+                         [:flip3,
+                          [:call,
+                           [:call, [:vcall, :i], :%, [:array, [:lit, 4]]],
+                           :==,
+                           [:array, [:lit, 0]]],
+                          [:call,
+                           [:call, [:vcall, :i], :%, [:array, [:lit, 3]]],
+                           :==,
+                           [:array, [:lit, 0]]]],
+                         [:vcall, :i],
+                         [:nil]]],
+    },
+
+    "for"  => {
+      "Ruby"        => "for o in ary\n  puts(o)\nend\n",
+      "ParseTree"   => [:for, [:vcall, :ary], [:lasgn, :o],
+                        [:fcall, :puts, [:array, [:lvar, :o]]]],
+    },
+
+    "gasgn"  => {
+      "Ruby"        => "$x = 42",
+      "ParseTree"   => [:gasgn, :$x, [:lit, 42]],
+    },
+
+    "global" => {
+      "Ruby"        => "$stderr",
+      "ParseTree"   =>  [:gvar, :$stderr],
+    },
+
+    "gvar"  => {
+      "Ruby"        => "$x",
+      "ParseTree"   => [:gvar, :$x],
+    },
+
+    "hash"  => {
+      "Ruby"        => "{ 1 => 2, 3 => 4 }",
+      "ParseTree"   => [:hash, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]],
+    },
+
+    "iasgn"  => {
+      "Ruby"        => "@a = 4",
+      "ParseTree"   => [:iasgn, :@a, [:lit, 4]],
+    },
+
+    "iteration1" => {
+      "Ruby"        => "loop { }",
+      "ParseTree"   => [:iter, [:fcall, :loop], nil],
+    },
+
+    "iteration2" => {
+      "Ruby" => "array = [1, 2, 3]\narray.each { |x| puts(x.to_s) }\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :array,
+                         [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
+                        [:iter,
+                         [:call, [:lvar, :array], :each],
+                         [:dasgn_curr, :x],
+                         [:fcall, :puts, [:array, [:call, [:dvar, :x], :to_s]]]]],
+    },
+
+    "iteration3" => {
+      "Ruby"        => "1.upto(3) { |n| puts(n.to_s) }",
+      "ParseTree"   => [:iter,
+                        [:call, [:lit, 1], :upto, [:array, [:lit, 3]]],
+                        [:dasgn_curr, :n],
+                        [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]],
+    },
+
+    "iteration4" => {
+      "Ruby"        => "3.downto(1) { |n| puts(n.to_s) }",
+      "ParseTree"   => [:iter,
+                        [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
+                        [:dasgn_curr, :n],
+                        [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]],
+    },
+
+    "iteration5" => {
+      "Ruby"        => "argl = 10\nwhile (argl >= 1) do\n  puts(\"hello\")\n  argl = (argl - 1)\nend\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :argl, [:lit, 10]],
+                        [:while,
+                         [:call, [:lvar, :argl], ">=".intern, [:array, [:lit, 1]]],
+                         [:block,
+                          [:fcall, :puts, [:array, [:str, "hello"]]],
+                          [:lasgn,
+                           :argl,
+                           [:call, [:lvar, :argl],
+                            "-".intern, [:array, [:lit, 1]]]]], true]],
+    },
+
+    "iteration6" => {
+      "Ruby"      => "array1 = [1, 2, 3]\narray2 = [4, 5, 6, 7]\narray1.each do |x|\n  array2.each do |y|\n    puts(x.to_s)\n    puts(y.to_s)\n  end\nend\n",
+      "ParseTree" => [:block,
+                      [:lasgn, :array1,
+                       [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
+                      [:lasgn, :array2,
+                       [:array, [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]],
+                      [:iter,
+                       [:call,
+                        [:lvar, :array1], :each],
+                       [:dasgn_curr, :x],
+                       [:iter,
+                        [:call,
+                         [:lvar, :array2], :each],
+                        [:dasgn_curr, :y],
+                        [:block,
+                         [:fcall, :puts,
+                          [:array, [:call, [:dvar, :x], :to_s]]],
+                         [:fcall, :puts,
+                          [:array, [:call, [:dvar, :y], :to_s]]]]]]],
+    },
+
+    "ivar" => {
+      "Ruby"        => [Examples, :reader],
+      "ParseTree"   => [:defn, :reader, [:ivar, :@reader]],
+      "Ruby2Ruby"   => "attr_reader :reader"
+    },
+
+    "lasgn_array" => {
+      "Ruby"        => "var = [\"foo\", \"bar\"]",
+      "ParseTree"   => [:lasgn, :var, [:array,
+                                       [:str, "foo"],
+                                       [:str, "bar"]]],
+    },
+
+    "lasgn_call" => {
+      "Ruby"        => "c = (2 + 3)",
+      "ParseTree"   => [:lasgn, :c, [:call, [:lit, 2], :+, [:array, [:lit, 3]]]],
+    },
+
+    "lit_bool_false" => {
+      "Ruby"        => "false",
+      "ParseTree"   => [:false],
+    },
+
+    "lit_bool_true" => {
+      "Ruby"        => "true",
+      "ParseTree"   => [:true],
+    },
+
+    "lit_float" => {
+      "Ruby"        => "1.1",
+      "ParseTree"   => [:lit, 1.1],
+    },
+
+    "lit_long" => {
+      "Ruby"        => "1",
+      "ParseTree"   => [:lit, 1],
+    },
+
+    "lit_range2" => {
+      "Ruby"        => "(1..10)",
+      "ParseTree"   => [:lit, 1..10],
+    },
+
+    "lit_range3" => {
+      "Ruby"        => "(1...10)",
+      "ParseTree"   => [:lit, 1...10],
+    },
+
+    "lit_regexp" => {
+      "Ruby"        => "/x/",
+      "ParseTree"   => [:lit, /x/],
+    },
+
+    "lit_str" => {
+      "Ruby"        => "\"x\"",
+      "ParseTree"   => [:str, "x"],
+    },
+
+    "lit_sym" => {
+      "Ruby"        => ":x",
+      "ParseTree"   => [:lit, :x],
+    },
+
+    "masgn"  => {
+      "Ruby"        => "a, b = c, d",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:array,  [:vcall, :c], [:vcall, :d]]],
+    },
+
+    "masgn_iasgn"  => {
+      "Ruby"        => "a, @b = c, d",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:iasgn, "@b".intern]],
+                        [:array,  [:vcall, :c], [:vcall, :d]]],
+    },
+
+    "masgn_attrasgn"  => {
+      "Ruby"        => "a, b.c = d, e",
+      "ParseTree"   => [:masgn,
+                         [:array, [:lasgn, :a], [:attrasgn, [:vcall, :b], :c=]],
+                         [:array, [:vcall, :d], [:vcall, :e]]],
+    },
+
+    "masgn_splat"  => {
+      "Ruby"        => "a, b, *c = d, e, f, g",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:lasgn, :c],
+                        [:array,
+                         [:vcall, :d], [:vcall, :e],
+                         [:vcall, :f], [:vcall, :g]]]
+    },
+
+
+    "match"  => {
+      "Ruby"        => "1 if /x/",
+      "ParseTree"   => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
+    },
+
+    "match2" => {
+      "Ruby"        => "/x/ =~ \"blah\"",
+      "ParseTree"   => [:match2, [:lit, /x/], [:str, "blah"]],
+    },
+
+    "match3" => {
+      "Ruby"        => "\"blah\" =~ /x/",
+      "ParseTree"   => [:match3, [:lit, /x/], [:str, "blah"]],
+    },
+
+    "module"  => {
+      "Ruby"        => "module X\n  def y\n    # do nothing\n  end\nend",
+      "ParseTree"   => [:module, :X,
+                        [:scope,
+                         [:defn, :y, [:scope, [:block, [:args], [:nil]]]]]],
+    },
+
+    "next"  => {
+      "Ruby"        => "loop { next if false }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :loop],
+                        nil,
+                        [:if, [:false], [:next], nil]],
+    },
+
+    "not"  => {
+      "Ruby"        => "(not true)",
+      "ParseTree"   => [:not, [:true]],
+    },
+
+    "nth_ref"  => {
+      "Ruby"        => "$1",
+      "ParseTree"   => [:nth_ref, 1],
+    },
+
+    "op_asgn1" => {
+      "Ruby"        => "b = []\nb[1] ||= 10\nb[2] &&= 11\nb[3] += 12\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :b, [:zarray]],
+                        [:op_asgn1, [:lvar, :b],
+                         [:array, [:lit, 1]], "||".intern, [:lit, 10]], # s->e
+                        [:op_asgn1, [:lvar, :b],
+                         [:array, [:lit, 2]], "&&".intern, [:lit, 11]], # s->e
+                        [:op_asgn1, [:lvar, :b],
+                         [:array, [:lit, 3]], :+, [:lit, 12]]],
+    },
+
+    "op_asgn2" => {
+      "Ruby"        => "s = Struct.new(:var)\nc = s.new(nil)\nc.var ||= 20\nc.var &&= 21\nc.var += 22\nc.d.e.f ||= 42\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :s,
+                         [:call, [:const, :Struct],
+                          :new, [:array, [:lit, :var]]]],
+                        [:lasgn, :c,
+                         [:call, [:lvar, :s], :new, [:array, [:nil]]]],
+
+                        [:op_asgn2, [:lvar, :c], :var=, "||".intern, # s->e
+                         [:lit, 20]],
+                        [:op_asgn2, [:lvar, :c], :var=, "&&".intern, # s->e
+                         [:lit, 21]],
+                        [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
+
+                        [:op_asgn2,
+                         [:call,
+                          [:call, [:lvar, :c], :d], :e], :f=, "||".intern,
+                         [:lit, 42]]],
+    },
+
+    "op_asgn_and" => {
+      "Ruby"        => "a = 0\na &&= 2\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :a, [:lit, 0]],
+                        [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]],
+    },
+
+    "op_asgn_or" => {
+      "Ruby"        => "a = 0\na ||= 1\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :a, [:lit, 0]],
+                        [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]],
+    },
+
+    "or"  => {
+      "Ruby"        => "(a or b)",
+      "ParseTree"   => [:or, [:vcall, :a], [:vcall, :b]],
+    },
+
+    "postexe"  => {
+      "Ruby"        => "END { 1 }",
+      "ParseTree"   => [:iter, [:postexe], nil, [:lit, 1]],
+    },
+
+    "proc_args" => {
+      "Ruby" => "proc { |x| (x + 1) }",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      [:dasgn_curr, :x],
+                      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
+    },
+
+    "proc_no_args" => {
+      "Ruby" => "proc { (x + 1) }",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      nil,
+                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+    },
+
+    "redo"  => {
+      "Ruby"        => "loop { redo if false }",
+      "ParseTree"   => [:iter,
+                        [:fcall, :loop], nil, [:if, [:false], [:redo], nil]],
+    },
+
+    "rescue"  => {
+      "Ruby"        => "blah rescue nil",
+      "ParseTree"   => [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]],
+    },
+
+    "rescue_block_body"  => {
+      "Ruby"        => "begin\n  blah\nrescue\n  42\nend",
+      "ParseTree"   => [:begin,
+                        [:rescue,
+                         [:vcall, :blah],
+                         [:resbody, nil, [:lit, 42]]]],
+    },
+
+    "rescue_block_nada"  => {
+      "Ruby"        => "begin\n  blah\nrescue\n  # do nothing\nend",
+      "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil]]]
+    },
+
+    "rescue_exceptions"  => {
+      "Ruby"        => "begin\n  blah\nrescue RuntimeError => r\n  # do nothing\nend",
+      "ParseTree"   => [:begin,
+                        [:rescue,
+                         [:vcall, :blah],
+                         [:resbody,
+                          [:array, [:const, :RuntimeError]],
+                          [:lasgn, :r, [:gvar, :$!]]]]],
+    },
+
+    "retry"  => {
+      "Ruby"        => "retry",
+      "ParseTree"   => [:retry],
+    },
+
+    "sclass"  => {
+      "Ruby"        => "class << self\n  42\nend",
+      "ParseTree"   => [:sclass, [:self], [:scope, [:lit, 42]]],
+    },
+
+    "splat"  => {
+      "Ruby"        => "a(*b)",
+      "ParseTree"   => [:fcall, :a, [:splat, [:vcall, :b]]],
+    },
+
+    # TODO: all supers need to pass args
+    "super"  => {
+      "Ruby"        => "def x\n  super(4)\nend",
+      "ParseTree"   => [:defn, :x,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:super, [:array, [:lit, 4]]]]]],
+    },
+
+    "super_multi"  => {
+      "Ruby"        => "def x\n  super(4, 2, 1)\nend",
+      "ParseTree"   => [:defn, :x,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:super, [:array, [:lit, 4], [:lit, 2], [:lit, 1]]]]]],
+    },
+
+    "svalue"  => {
+      "Ruby"        => "a = *b",
+      "ParseTree"   => [:lasgn, :a, [:svalue, [:splat, [:vcall, :b]]]],
+    },
+
+    "to_ary"  => {
+      "Ruby"        => "a, b = c",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:to_ary, [:vcall, :c]]],
+    },
+
+    "true" => {
+      "Ruby"      => "true",
+      "ParseTree" => [:true],
+    },
+
+    "undef"  => {
+      "Ruby"        => "undef :x",
+      "ParseTree"   => [:undef, [:lit, :x]],
+    },
+
+    "undef_multi"  => {
+      "Ruby"        => "undef :x, :y, :z",
+      "ParseTree"   => [:block,
+                        [:undef, [:lit, :x]],
+                        [:undef, [:lit, :y]],
+                        [:undef, [:lit, :z]]],
+      "Ruby2Ruby"   => "undef :x\nundef :y\nundef :z\n",
+    },
+
+    "until_post"  => {
+      "Ruby"        => "begin\n  (1 + 1)\nend until false",
+      "ParseTree"   => [:until, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+    },
+
+    "until_pre"  => {
+      "Ruby"        => "until false do\n  (1 + 1)\nend",
+      "ParseTree"   => [:until, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+    },
+
+    "valias"  => {
+      "Ruby"        => "alias $y $x",
+      "ParseTree"   => [:valias, :$y, :$x],
+    },
+
+    "vcall" => {
+      "Ruby"        => "method",
+      "ParseTree"   => [:vcall, :method],
+    },
+
+    "while_pre" => {
+      "Ruby"        => "while false do\n  (1 + 1)\nend",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+    },
+
+    "while_pre_nil" => {
+      "Ruby"        => "while false do\nend",
+      "ParseTree"   => [:while, [:false], nil, true],
+    },
+
+    "while_post" => {
+      "Ruby"        => "begin\n  (1 + 1)\nend while false",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+    },
+
+    "xstr" => {
+      "Ruby"        => "`touch 5`",
+      "ParseTree"   => [:xstr, 'touch 5'],
+    },
+
+    "yield"  => {
+      "Ruby"        => "yield",
+      "ParseTree"   => [:yield],
+    },
+
+    "yield_arg"  => {
+      "Ruby"        => "yield(42)",
+      "ParseTree"   => [:yield, [:lit, 42]],
+    },
+
+    "yield_args"  => {
+      "Ruby"        => "yield(42, 24)",
+      "ParseTree"   => [:yield, [:array, [:lit, 42], [:lit, 24]]],
+    },
+
+    "zarray" => {
+      "Ruby"        => "a = []",
+      "ParseTree"   => [:lasgn, :a, [:zarray]],
+    },
+
+    "zsuper"  => {
+      "Ruby"        => "def x\n  super\nend",
+      "ParseTree"   => [:defn, :x, [:scope, [:block, [:args], [:zsuper]]]],
+    },
+  }
+
+#   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
+    when "RubyToRubyC" then
+      idx -= 1
+    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}" unless @@testcase_order.include? output_name
+
+    input_name = self.previous(output_name)
+
+    @@testcases.each do |node, data|
+      next if [:skip, :unsupported].include? data[input_name]
+      next if data[output_name] == :skip
+
+      c.send(:define_method, "test_#{node}".intern) do
+        flunk "Processor is nil" if processor.nil?
+        assert data.has_key?(input_name), "Unknown input data"
+        unless data.has_key?(output_name) then
+          $stderr.puts "add_test(#{node.inspect}, :same)"
+        end
+        assert data.has_key?(output_name), "Missing test data: #{self.class} #{node}"
+        input = data[input_name].deep_clone
+
+        expected = if data[output_name] == :same then
+                     input
+                   else
+                     data[output_name]
+                   end.deep_clone
+
+        case expected
+        when :unsupported then
+          assert_raises(UnsupportedNodeError) do
+            processor.process(input)
+          end
+        else
+          extra_expected = []
+          extra_input = []
+
+          _, expected, extra_expected = *expected if Array === expected and expected.first == :defx
+          _, input, extra_input = *input if Array === input and input.first == :defx
+
+          debug = input.deep_clone
+          $-w = nil if node == "match"
+          assert_equal expected, processor.process(input), "failed on input: #{debug.inspect}"
+          $-w = true if node == "match"
+          extra_input.each do |input| processor.process(input) end
+          extra = processor.extra_methods rescue []
+          assert_equal extra_expected, extra
+        end
+      end
+    end
+  end
+
+  undef_method :default_test
+end