ParseTree 1.4.1 → 1.5.0

data/History.txt

@@ -1,3 +1,19 @@
+*** 1.5.0 / 2006-09-24
+
++ 5 minor enhancements:
+	Added parse_tree_audit.
+	Added reporting of unsupported nodes that have processors.
+	YAY! class method support! generated as :"self.blah"
+	Add parse_tree_for_string.
+	Converted Rakefile+gemspec to Hoe-based Rakefile.
++ 6 bug fixes:
+	Did some preliminary work on 1.9 compatibility.
+	Fixed tests for some changes/clarifications.
+	Fixed resbody: should have nil exceptions list when no exception rescued.
+	Fixed op_asgn1 and op_asgn2.
+	Fixed incompatibility with new inline changes.
+	Fixed VALUE decl in parse_tree.rb
+
 *** 1.4.1 / 2006-04-10
 
 + 4 minor enhancements:

data/Manifest.txt

@@ -1,9 +1,9 @@
 History.txt
 Rakefile
 Manifest.txt
-ParseTree.gemspec
 README.txt
 bin/parse_tree_abc
+bin/parse_tree_audit
 bin/parse_tree_deps
 bin/parse_tree_show
 demo/printer.rb
@@ -11,6 +11,7 @@ lib/composite_sexp_processor.rb
 lib/parse_tree.rb
 lib/sexp.rb
 lib/sexp_processor.rb
+test/pt_testcase.rb
 test/something.rb
 test/test_all.rb
 test/test_composite_sexp_processor.rb

data/Rakefile

@@ -1,80 +1,30 @@
 # -*- ruby -*-
 
-require 'rbconfig'
-require 'rake/rdoctask'
+require 'rubygems'
+require 'hoe'
 
-PREFIX = ENV['PREFIX'] || Config::CONFIG['prefix']
-RUBYLIB = Config::CONFIG['sitelibdir']
-RUBY_DEBUG = ENV['RUBY_DEBUG']
-RUBY_FLAGS = ENV['RUBY_FLAGS'] || "-w -Ilib#{File::PATH_SEPARATOR}bin#{File::PATH_SEPARATOR}../../RubyInline/dev"
-FILTER = ENV['FILTER']
+$: << "../../RubyInline/dev"
+require './lib/parse_tree.rb'
 
-LIB_FILES = %w(composite_sexp_processor.rb parse_tree.rb sexp.rb sexp_processor.rb)
-TEST_FILES = %w(test_sexp_processor.rb)
-BIN_FILES = %w(parse_tree_abc parse_tree_show parse_tree_deps)
-
-task :default => :test
-
-task :test do
-  ruby "#{RUBY_FLAGS} test/test_all.rb #{FILTER}"
-end
-
-task :multi do
-  sh "multiruby #{RUBY_FLAGS} test/test_all.rb #{FILTER}"
-end
-
-# we only install test_sexp_processor.rb to help make ruby_to_c's
-# subclass tests work.
-
-Rake::RDocTask.new(:docs) do |rd|
-  rd.main = "SexpProcessor"
-  rd.rdoc_files.include('./**/*').exclude('something.rb').exclude('test_*')
-  rd.options << '-d'
-  rd.options << '-Ipng'
+Hoe.new("ParseTree", ParseTree::VERSION) do |p|
+  p.summary = "Extract and enumerate ruby parse trees."
+  p.description = File.read("README.txt").split(/\n\n+/)[2]
+  p.clean_globs << File.expand_path("~/.ruby_inline")
+  p.extra_deps << ['RubyInline', '>= 3.2.0']
 end
 
-task :install do
-  [
-   ['lib', LIB_FILES, RUBYLIB, 0444],
-   ['test', TEST_FILES, RUBYLIB, 0444],
-   ['bin', BIN_FILES, File.join(PREFIX, 'bin'), 0555]
-  ].each do |dir, list, dest, mode|
-    Dir.chdir dir do
-      list.each do |f|
-        install f, dest, :mode => mode
-      end
-    end
-  end
+desc 'Run against ruby 1.9 (from a multiruby install) with -d.'
+task :test19 do
+  sh "~/.multiruby/install/1_9/bin/ruby -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
 end
 
-task :uninstall do
-  Dir.chdir RUBYLIB do
-    rm_f LIB_FILES
-    rm_f TEST_FILES
-  end
-  Dir.chdir File.join(PREFIX, 'bin') do
-    rm_f BIN_FILES
-  end
-end
-
-task :audit do
-  sh "ZenTest -Ilib#{File::PATH_SEPARATOR}test #{LIB_FILES.collect{|e| File.join('lib', e)}.join(' ')} test/test_all.rb"
-  # test_composite_sexp_processor.rb test_sexp_processor.rb
-end
-
-task :clean do
-  inline_dir = File.expand_path("~/.ruby_inline")
-  rm_rf inline_dir if test ?d, inline_dir
-  %w(diff diff.txt demo.rb *.gem **/*~).each do |pattern|
-    files = Dir[pattern]
-    rm_rf files unless files.empty?
-  end
+desc 'Run in gdb'
+task :debug do
+  puts "RUN: r -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
+  sh "gdb ~/.multiruby/install/19/bin/ruby"
 end
 
+desc 'Run a very basic demo'
 task :demo do
-  verbose(false){sh "echo 1+1 | ruby #{RUBY_FLAGS} ./bin/parse_tree_show -f"}
-end
-
-task :gem do
-  ruby "ParseTree.gemspec"
+  sh "echo 1+1 | ruby #{Hoe::RUBY_FLAGS} ./bin/parse_tree_show -f"
 end

data/bin/parse_tree_audit

@@ -0,0 +1,28 @@
+#!/usr/local/bin/ruby -w
+
+require 'parse_tree'
+
+all_nodes = ParseTree::NODE_NAMES
+
+ARGV.each do |processor|
+  require processor
+end
+
+ObjectSpace.each_object(Class) do |klass| 
+  if klass < SexpProcessor then
+
+    processor = klass.new
+    processors = klass.public_instance_methods(true).grep(/process_/)
+
+    if processor.strict then
+      puts "#{klass.name}:"
+      puts
+
+      # TODO: check unsupported against supported
+      processors = processors.map { |m| m[8..-1].intern } + processor.unsupported
+      unsupported = all_nodes - processors 
+      p unsupported.sort_by { |sym| sym.to_s }
+      puts
+    end
+  end
+end

data/lib/parse_tree.rb

@@ -25,7 +25,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.4.1'
+  VERSION = '1.5.0'
 
   ##
   # Initializes a ParseTree instance. Includes newline nodes if
@@ -76,9 +76,13 @@ class ParseTree
       # protected methods are included in instance_methods, go figure!
 
       method_names.sort.each do |m|
-        $stderr.puts "parse_tree_for_method(#{klass}, #{m}):" if $DEBUG
         code << parse_tree_for_method(klass, m.to_sym)
       end
+
+      klass.singleton_methods.sort.each do |m|
+        code << parse_tree_for_method(klass, m.to_sym, true)
+      end
+
       result << code
     end
     return result
@@ -91,8 +95,25 @@ class ParseTree
   #
   #   [:defn, :name, :body]
 
-  def parse_tree_for_method(klass, method)
-    parse_tree_for_meth(klass, method.to_sym, @include_newlines)
+  def parse_tree_for_method(klass, method, is_cls_meth=false)
+    $stderr.puts "** parse_tree_for_method(#{klass}, #{method}):" if $DEBUG
+    r = parse_tree_for_meth(klass, method.to_sym, @include_newlines, is_cls_meth)
+    r[1] = :"self.#{r[1]}" if is_cls_meth
+    r
+  end
+
+  ##
+  # Returns the parse tree for a string +source+.
+  #
+  # Format:
+  #
+  #   [[sexps] ... ]
+
+  def parse_tree_for_string(source, filename = nil, line = nil,
+                            newlines = false)
+    filename ||= '(string)'
+    line ||= 1
+    return parse_tree_for_str(source, filename, line, newlines)
   end
 
   if RUBY_VERSION < "1.8.4" then
@@ -149,7 +170,6 @@ class ParseTree
                 :newline, :postexe, :alloca, :dmethod, :bmethod,
                 # 100
                 :memo, :ifunc, :dsym, :attrasgn,
-                # 104
                 :last
                ]
 
@@ -171,11 +191,11 @@ class ParseTree
 
   inline do |builder|
     builder.add_type_converter("bool", '', '')
-    builder.add_type_converter("VALUE", '', '')
     builder.add_type_converter("ID *", '', '')
     builder.add_type_converter("NODE *", '(NODE *)', '(VALUE)')
     builder.include '"intern.h"'
     builder.include '"version.h"'
+    builder.include '"rubysig.h"'
     builder.include '"node.h"'
     builder.include '"st.h"'
     builder.include '"env.h"'
@@ -238,7 +258,10 @@ class ParseTree
           struct BLOCK *outer;
           struct BLOCK *prev;
         };
-    } unless RUBY_VERSION >= "1.9"
+    } unless RUBY_VERSION >= "1.9" # we got matz to add this to env.h
+
+  ##
+  # add_to_parse_tree(ary, node, include_newlines, local_variables)
 
   builder.c_raw %Q@
 static void add_to_parse_tree(VALUE ary,
@@ -400,7 +423,11 @@ again_no_block:
   // a = b rescue c
 
   case NODE_RESBODY:
-      add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+      if (node->nd_3rd) {
+        add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
       add_to_parse_tree(current, node->nd_2nd, newlines, locals);
       add_to_parse_tree(current, node->nd_1st, newlines, locals);
     break;
@@ -484,11 +511,36 @@ again_no_block:
   case NODE_OP_ASGN1:
     add_to_parse_tree(current, node->nd_recv, newlines, locals);
     add_to_parse_tree(current, node->nd_args->nd_next, newlines, locals);
+    switch (node->nd_mid) {
+    case 0:
+      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      break;
+    case 1:
+      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      break;
+    default:
+      rb_ary_push(current, ID2SYM(node->nd_mid));
+      break;
+    }
     add_to_parse_tree(current, node->nd_args->nd_head, newlines, locals);
     break;
 
   case NODE_OP_ASGN2:
     add_to_parse_tree(current, node->nd_recv, newlines, locals);
+    rb_ary_push(current, ID2SYM(node->nd_next->nd_aid));
+
+    switch (node->nd_next->nd_mid) {
+    case 0:
+      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      break;
+    case 1:
+      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      break;
+    default:
+      rb_ary_push(current, ID2SYM(node->nd_next->nd_mid));
+      break;
+    }
+
     add_to_parse_tree(current, node->nd_value, newlines, locals);
     break;
 
@@ -611,9 +663,11 @@ again_no_block:
     long arg_count = (long)node->nd_rest;
     if (locals && (node->nd_cnt || node->nd_opt || arg_count != -1)) {
       int i;
+      int max_args;
       NODE *optnode;
 
-      for (i = 0; i < node->nd_cnt; i++) {
+      max_args = node->nd_cnt;
+      for (i = 0; i < max_args; i++) {
         // regular arg names
         rb_ary_push(current, ID2SYM(locals[i + 3]));
       }
@@ -736,6 +790,15 @@ again_no_block:
     rb_ary_push(current, INT2FIX(node->nd_argc));
     break;
 
+#{if_version :<, "1.9", "#if 0"}
+  case NODE_ERRINFO:
+  case NODE_VALUES:
+  case NODE_PRELUDE:
+  case NODE_LAMBDA:
+    puts("no worky in 1.9 yet");
+    break;
+#{if_version :<, "1.9", "#endif"}
+
   // Nodes we found but have yet to decypher
   // I think these are all runtime only... not positive but...
   case NODE_MEMO:               // enum.c zip
@@ -768,14 +831,13 @@ again_no_block:
 @ # end of add_to_parse_tree block
 
     builder.c %Q{
-static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
+static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines, VALUE is_cls_meth) {
   VALUE n;
   NODE *node = NULL;
   ID id;
   VALUE result = rb_ary_new();
 
   (void) self; // quell warnings
-  (void) argc; // quell warnings
 
   VALUE version = rb_const_get_at(rb_cObject,rb_intern("RUBY_VERSION"));
   if (strcmp(StringValuePtr(version), #{RUBY_VERSION.inspect})) {
@@ -783,6 +845,9 @@ static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
   }
 
   id = rb_to_id(method);
+  if (RTEST(is_cls_meth)) { // singleton method
+    klass = CLASS_OF(klass);
+  }
   if (st_lookup(RCLASS(klass)->m_tbl, id, &n)) {
     node = (NODE*)n;
     rb_ary_push(result, ID2SYM(rb_intern("defn")));
@@ -795,5 +860,53 @@ static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
   return result;
 }
 }
+
+    builder.prefix " extern NODE *ruby_eval_tree_begin; " \
+      if RUBY_VERSION < '1.9.0'
+
+    builder.c %Q{
+static VALUE parse_tree_for_str(VALUE source, VALUE filename, VALUE line,
+                                   VALUE newlines) {
+  VALUE tmp;
+  VALUE result = rb_ary_new();
+  NODE *node = NULL;
+  int critical;
+
+  (void) self; // quell warnings
+
+  tmp = rb_check_string_type(filename);
+  if (NIL_P(tmp)) {
+    filename = rb_str_new2("(string)");
+  }
+
+  if (NIL_P(line)) {
+    line = LONG2FIX(1);
+  }
+
+  newlines = RTEST(newlines);
+
+  ruby_nerrs = 0;
+  StringValue(source);
+  critical = rb_thread_critical;
+  rb_thread_critical = Qtrue;
+  ruby_in_eval++;
+  node = rb_compile_string(StringValuePtr(filename), source, NUM2INT(line));
+  ruby_in_eval--;
+  rb_thread_critical = critical;
+
+  if (ruby_nerrs > 0) {
+    ruby_nerrs = 0;
+#if RUBY_VERSION_CODE < 190
+    ruby_eval_tree_begin = 0;
+#endif
+    rb_exc_raise(ruby_errinfo);
+  }
+
+  add_to_parse_tree(result, node, newlines, NULL);
+
+  return result;
+}
+}
+
   end # inline call
 end # ParseTree class

data/lib/sexp_processor.rb

@@ -138,6 +138,7 @@ class SexpProcessor
     @auto_shift_type = false
     @strict = false
     @unsupported = []
+    @unsupported_checked = false
     @debug = {}
     @expected = Sexp
     @require_empty = true
@@ -167,6 +168,15 @@ class SexpProcessor
   def process(exp)
     return nil if exp.nil?
 
+    unless @unsupported_checked then
+      m = public_methods.grep(/^process_/) { |o| o.sub(/^process_/, '').intern }
+      supported = m - (m - @unsupported)
+
+      raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?
+
+      @unsupported_checked = true
+    end
+
     result = self.expected.new
 
     type = exp.first
@@ -307,7 +317,7 @@ class SexpProcessor
   #   end
 
   def process_dummy(exp)
-    result = @expected.new(:dummy)
+    result = @expected.new(:dummy) rescue @expected.new
     until exp.empty? do
       result << self.process(exp.shift)
     end

data/test/pt_testcase.rb

@@ -0,0 +1,1378 @@
+require 'test/unit/testcase'
+require 'sexp_processor' # for deep_clone FIX
+require 'typed_sexp'
+require 'unique'
+
+# TODO: str -> char * in ansi c
+# TODO: add tests that mix types up to fuck up RubyC type checker
+
+class R2CTestCase < 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
+
+  @@testcase_order = %w(Ruby ParseTree Rewriter TypeChecker CRewriter RubyToAnsiC RubyToRubyC)
+
+  @@testcases = {
+
+    "accessor" => {
+      "Ruby"        => "attr_reader :accessor",
+      "ParseTree"   => [:defn, :accessor, [:ivar, :@accessor]],
+      "Rewriter"    => s(:defn, :accessor, s(:args),
+                         s(:scope,
+                           s(:block, s(:return, s(:ivar, :@accessor))))),
+      "TypeChecker" => :skip,
+      "CRewriter"   => :skip,
+      "RubyToAnsiC" => :skip,
+      "RubyToRubyC" => :skip,
+    },
+
+    "accessor_equals" => {
+      "Ruby"        => "attr_writer :accessor",
+      "ParseTree"   => [:defn, :accessor=, [:attrset, :@accessor]],
+      "Rewriter"    => s(:defn,
+                        :accessor=,
+                        s(:args, :arg),
+                        s(:scope,
+                          s(:block,
+                            s(:return,
+                              s(:iasgn, :@accessor, s(:lvar, :arg)))))),
+      "TypeChecker" => :skip,
+      "CRewriter"   => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "defn_bbegin" => {
+      "Ruby"        => "def bbegin()
+  begin
+    1 + 1
+  rescue SyntaxError
+    e1 = $!
+    2
+  rescue Exception
+    e2 = $!
+    3
+  else
+    4end
+  ensure
+    5
+end",
+     "ParseTree"   => [:defn, :bbegin,
+       [:scope,
+         [:block,
+           [:args],
+           [: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]]]]]],
+      "Rewriter" => s(:defn, :bbegin,
+               s(:args),
+               s(:scope,
+                 s(:block,
+                   s(:begin,
+                     s(:ensure,
+                       s(:rescue,
+                         s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))),
+                         s(:resbody,
+                           s(:array, s(:const, :SyntaxError)),
+                           s(:block, s(:lasgn, :e1, s(:gvar, :$!)),
+                             s(:lit, 2)),
+                           s(:resbody,
+                             s(:array, s(:const, :Exception)),
+                             s(:block, s(:lasgn, :e2, s(:gvar, :$!)),
+                               s(:lit, 3)))),
+                         s(:lit, 4)),
+                       s(:lit, 5)))))),
+      "TypeChecker" => t(:defn, :bbegin,
+               t(:args),
+               t(:scope,
+                 t(:block,
+                   t(:begin,
+                     t(:ensure,
+                       t(:rescue,
+                         t(:call,
+                           t(:lit, 1, Type.long),
+                           :+,
+                           t(:arglist, t(:lit, 1, Type.long)), Type.long),
+                         t(:resbody,
+                           t(:array, t(:const, :SyntaxError, Type.fucked)),
+                           t(:block,
+                             t(:lasgn, :e1, t(:gvar, :$!, Type.unknown),
+                               Type.unknown),
+                             t(:lit, 2, Type.long), Type.unknown),
+                           t(:resbody,
+                             t(:array, t(:const, :Exception, Type.fucked)),
+                             t(:block,
+                               t(:lasgn, :e2, t(:gvar, :$!, Type.unknown),
+                                 Type.unknown),
+                               t(:lit, 3, Type.long), Type.unknown),
+                             Type.unknown), Type.long),
+                         t(:lit, 4, Type.long), Type.long),
+                       t(:lit, 5, Type.long))), Type.unknown),
+                 Type.void),
+               Type.function(Type.unknown, [], Type.void)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => :unsupported,
+      "RubyToAnsiC" => :unsupported,
+    },
+
+    "bools" => {
+      "Ruby"      => "def bools(arg1)
+  if (arg1.nil?)
+    return false
+  else
+    return true
+  end
+end",
+      "ParseTree" => [:defn, :bools,
+        [:scope,
+          [:block,
+            [:args, :arg1],
+            [:if,
+              [:call, [:lvar, :arg1], "nil?".intern], # emacs is freakin'
+              [:return, [:false]],
+              [:return, [:true]]]]]],
+      "Rewriter" => s(:defn, :bools,
+              s(:args, :arg1),
+              s(:scope,
+                s(:block,
+                  s(:if,
+                    s(:call,
+                      s(:lvar, :arg1),
+                      :nil?,
+                      nil),
+                    s(:return, s(:false)),
+                    s(:return, s(:true)))))),
+      # TODO: why does return false have type void?
+      "TypeChecker" => t(:defn, :bools,
+                         t(:args, t(:arg1, Type.value)),
+                         t(:scope,
+                           t(:block,
+                             t(:if,
+                               t(:call,
+                                 t(:lvar, :arg1, Type.value),
+                                 :nil?,
+                                 nil,
+                                 Type.bool),
+                               t(:return,
+                                 t(:false, Type.bool),
+                                 Type.void),
+                               t(:return,
+                                 t(:true, Type.bool),
+                                 Type.void),
+                               Type.void),
+                             Type.unknown),
+                           Type.void),
+                         Type.function(Type.unknown, [Type.value], Type.bool)),
+      "CRewriter" => :same,
+      "RubyToRubyC"     => "static VALUE\nrrc_c_bools(VALUE self, VALUE arg1) {\nif (NIL_P(arg1)) {\nreturn Qfalse;\n} else {\nreturn Qtrue;\n}\n}",
+      "RubyToAnsiC"     => "bool\nbools(void * arg1) {\nif (arg1) {\nreturn 0;\n} else {\nreturn 1;\n}\n}",
+    },
+
+# TODO: move all call tests here
+    "call_arglist"  => {
+      "Ruby"        => "puts(42)",
+      "ParseTree"   => [:fcall,      :puts,  [:array,    [:lit, 42]]],
+      "Rewriter"    => s(:call, nil, :puts, s(:arglist, s(:lit, 42))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "call_attrasgn" => {
+      "Ruby"        => "42.method=(y)",
+      "ParseTree"   => [:attrasgn, [:lit, 42], :method=, [:array, [:lvar, :y]]],
+      "Rewriter"    => s(:call,   s(:lit, 42), :method=, s(:arglist, s(:lvar, :y))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "call_self" => {
+      "Ruby"        => "self.method",
+      "ParseTree" => [:call, [:self], :method],
+      "Rewriter"  => s(:call, s(:lvar, :self), :method, nil),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "case_stmt" => {
+      "Ruby"        => "
+def case_stmt()
+  var = 2
+  result = \"\"
+  case var
+  when 1
+    puts(\"something\")
+    result = \"red\"
+  when 2, 3
+    result = \"yellow\"
+  when 4
+  else
+    result = \"green\"
+  end
+  case result
+  when \"red\"
+    var = 1
+  when \"yellow\"
+    var = 2
+  when \"green\"
+    var = 3
+  else
+  end
+  return result
+end",
+      "ParseTree" => [:defn, :case_stmt,
+   [:scope,
+    [:block,
+     [:args],
+     [: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],
+     [:return, [:lvar, :result]]]]],
+      "Rewriter" => s(:defn, :case_stmt,
+                  s(:args),
+                  s(:scope,
+                    s(:block,
+                      s(:lasgn, :var, s(:lit, 2)),
+                      s(:lasgn, :result, s(:str, "")),
+                      s(:if,
+                        s(:call,
+                          s(:lvar, :var),
+                          :===,
+                          s(:arglist, s(:lit, 1))),
+                        s(:block,
+                          s(:call,
+                            nil,
+                            :puts,
+                            s(:arglist, s(:str, "something"))),
+                          s(:lasgn, :result, s(:str, "red"))),
+                        s(:if,
+                          s(:or,
+                            s(:call,
+                              s(:lvar, :var),
+                              :===,
+                              s(:arglist, s(:lit, 2))),
+                            s(:call,
+                              s(:lvar, :var),
+                              :===,
+                              s(:arglist, s(:lit, 3)))),
+                          s(:lasgn, :result, s(:str, "yellow")),
+                          s(:if,
+                            s(:call,
+                              s(:lvar, :var),
+                              :===,
+                              s(:arglist, s(:lit, 4))),
+                            nil,
+                            s(:lasgn, :result, s(:str, "green"))))),
+                      s(:if,
+                        s(:call,
+                          s(:lvar, :result),
+                          :===,
+                          s(:arglist, s(:str, "red"))),
+                        s(:lasgn, :var, s(:lit, 1)),
+                        s(:if,
+                          s(:call,
+                            s(:lvar, :result),
+                            :===,
+                            s(:arglist, s(:str, "yellow"))),
+                          s(:lasgn, :var, s(:lit, 2)),
+                          s(:if,
+                            s(:call,
+                              s(:lvar, :result),
+                              :===,
+                              s(:arglist, s(:str, "green"))),
+                            s(:lasgn, :var, s(:lit, 3)),
+                            nil))),
+                      s(:return, s(:lvar, :result))))),
+      "TypeChecker" => t(:defn, :case_stmt,
+                         t(:args),
+                         t(:scope,
+                           t(:block,
+                             t(:lasgn,
+                               :var,
+                               t(:lit, 2, Type.long),
+                               Type.long),
+                             t(:lasgn,
+                               :result,
+                               t(:str, "", Type.str),
+                               Type.str),
+                             t(:if,
+                               t(:call,
+                                 t(:lvar, :var, Type.long),
+                                 :case_equal_long,
+                                 t(:arglist, t(:lit, 1, Type.long)),
+                                 Type.bool),
+                               t(:block,
+                                 t(:call,
+                                   nil,
+                                   :puts,
+                                   t(:arglist,
+                                     t(:str, "something", Type.str)),
+                                   Type.void),
+                                 t(:lasgn,
+                                   :result,
+                                   t(:str, "red", Type.str),
+                                   Type.str),
+                                 Type.str),
+                               t(:if,
+                                 t(:or,
+                                   t(:call,
+                                     t(:lvar, :var, Type.long),
+                                     :case_equal_long,
+                                     t(:arglist, t(:lit, 2, Type.long)),
+                                     Type.bool),
+                                   t(:call,
+                                     t(:lvar, :var, Type.long),
+                                     :case_equal_long,
+                                     t(:arglist, t(:lit, 3, Type.long)),
+                                     Type.bool),
+                                   Type.bool),
+                                 t(:lasgn,
+                                   :result,
+                                   t(:str, "yellow", Type.str),
+                                   Type.str),
+                                 t(:if,
+                                   t(:call,
+                                     t(:lvar, :var, Type.long),
+                                     :case_equal_long,
+                                     t(:arglist, t(:lit, 4, Type.long)),
+                                     Type.bool),
+                                   nil,
+                                   t(:lasgn,
+                                     :result,
+                                     t(:str, "green", Type.str),
+                                     Type.str),
+                                   Type.str),
+                                 Type.str),
+                               Type.str),
+                             t(:if,
+                               t(:call,
+                                 t(:lvar, :result, Type.str),
+                                 :case_equal_str,
+                                 t(:arglist, t(:str, "red", Type.str)),
+                                 Type.bool),
+                               t(:lasgn, :var, t(:lit, 1, Type.long), Type.long),
+                               t(:if,
+                                 t(:call,
+                                   t(:lvar, :result, Type.str),
+                                   :case_equal_str,
+                                   t(:arglist, t(:str, "yellow", Type.str)),
+                                   Type.bool),
+                                 t(:lasgn, :var, t(:lit, 2, Type.long), Type.long),
+                                 t(:if,
+                                   t(:call,
+                                     t(:lvar, :result, Type.str),
+                                     :case_equal_str,
+                                     t(:arglist,
+                                       t(:str, "green", Type.str)),
+                                     Type.bool),
+                                   t(:lasgn,
+                                     :var,
+                                     t(:lit, 3, Type.long),
+                                     Type.long),
+                                   nil,
+                                   Type.long),
+                                 Type.long),
+                               Type.long),
+                             t(:return,
+                               t(:lvar, :result, Type.str),
+                               Type.void),
+                             Type.unknown),
+                           Type.void),
+                         Type.function(Type.unknown, [], Type.str)),
+      "CRewriter" => :same,
+# HACK: I don't like the semis after the if blocks, but it is a compromise right now
+      "RubyToRubyC" => "static VALUE
+rrc_c_case_stmt(VALUE self) {
+VALUE result;
+VALUE var;
+var = LONG2NUM(2);
+result = rb_str_new2(\"\");
+if (rb_funcall(var, rb_intern(\"===\"), 1, LONG2NUM(1))) {
+rb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"something\"));
+result = rb_str_new2(\"red\");
+} else {
+if (rb_funcall(var, rb_intern(\"===\"), 1, LONG2NUM(2)) || rb_funcall(var, rb_intern(\"===\"), 1, LONG2NUM(3))) {
+result = rb_str_new2(\"yellow\");
+} else {
+if (rb_funcall(var, rb_intern(\"===\"), 1, LONG2NUM(4))) {
+;
+} else {
+result = rb_str_new2(\"green\");
+}
+}
+};
+if (rb_funcall(result, rb_intern(\"===\"), 1, rb_str_new2(\"red\"))) {
+var = LONG2NUM(1);
+} else {
+if (rb_funcall(result, rb_intern(\"===\"), 1, rb_str_new2(\"yellow\"))) {
+var = LONG2NUM(2);
+} else {
+if (rb_funcall(result, rb_intern(\"===\"), 1, rb_str_new2(\"green\"))) {
+var = LONG2NUM(3);
+}
+}
+};
+return result;
+}",
+      "RubyToAnsiC" => "str
+case_stmt() {
+str result;
+long var;
+var = 2;
+result = \"\";
+if (case_equal_long(var, 1)) {
+puts(\"something\");
+result = \"red\";
+} else {
+if (case_equal_long(var, 2) || case_equal_long(var, 3)) {
+result = \"yellow\";
+} else {
+if (case_equal_long(var, 4)) {
+;
+} else {
+result = \"green\";
+}
+}
+};
+if (case_equal_str(result, \"red\")) {
+var = 1;
+} else {
+if (case_equal_str(result, \"yellow\")) {
+var = 2;
+} else {
+if (case_equal_str(result, \"green\")) {
+var = 3;
+}
+}
+};
+return result;
+}",
+    },
+
+    "conditional1" => {
+      "Ruby"        => "if (42 == 0)\n  return 1\n\nend",
+      "ParseTree"   => [:if, [:call, [:lit, 42], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil],
+      "Rewriter"    => s(:if, s(:call, s(:lit, 42), :==, s(:arglist, s(:lit, 0))), s(:return, s(:lit, 1)), nil),
+      "TypeChecker" => t(:if,
+                         t(:call, t(:lit, 42, Type.long), :==,
+                           t(:arglist, t(:lit, 0, Type.long)),
+                           Type.bool),
+                         t(:return, t(:lit, 1, Type.long), Type.void),
+                         nil,
+                         Type.void),
+      "CRewriter" => t(:if,
+                         t(:call, t(:lit, 42, Type.long), :==,
+                           t(:arglist, t(:lit, 0, Type.long)),
+                           Type.bool),
+                         t(:return, t(:lit, 1, Type.long), Type.void),
+                         nil,
+                         Type.void),
+      "RubyToRubyC" => "if (rb_funcall(LONG2NUM(42), rb_intern(\"==\"), 1, LONG2NUM(0))) {\nreturn LONG2NUM(1);\n}",
+      "RubyToAnsiC" => "if (42 == 0) {\nreturn 1;\n}",
+    },
+
+    "conditional2" => {
+      "Ruby"        => "unless (42 == 0)\n  return 2\nend",
+      "ParseTree"   => [:if, [:call, [:lit, 42], :==, [:array, [:lit, 0]]], nil, [:return, [:lit, 2]]],
+      "Rewriter"    => s(:if,
+                         s(:call, s(:lit, 42),
+                           :==, s(:arglist, s(:lit, 0))),
+                         nil,
+                         s(:return, s(:lit, 2))),
+      "TypeChecker" => t(:if,
+                         t(:call,
+                           t(:lit, 42, Type.long),
+                           :==,
+                           t(:arglist,
+                             t(:lit, 0, Type.long)),
+                           Type.bool),
+                         nil,
+                         t(:return, t(:lit, 2, Type.long), Type.void),
+                         Type.void),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "if (rb_funcall(LONG2NUM(42), rb_intern(\"==\"), 1, LONG2NUM(0))) {\n;\n} else {\nreturn LONG2NUM(2);\n}",
+      "RubyToAnsiC" => "if (42 == 0) {\n;\n} else {\nreturn 2;\n}",
+    },
+
+    "conditional3" => {
+      "Ruby"        => "if (42 == 0)\n  return 3\nelse\n  return 4\nend",
+      "ParseTree"   => [:if, [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+        [:return, [:lit, 3]],
+        [:return, [:lit, 4]]],
+      "Rewriter"    => s(:if,
+                         s(:call,
+                           s(:lit, 42),
+                           :==,
+                           s(:arglist, s(:lit, 0))),
+                         s(:return, s(:lit, 3)),
+                         s(:return, s(:lit, 4))),
+      "TypeChecker" => t(:if,
+                         t(:call,
+                           t(:lit, 42, Type.long),
+                           :==,
+                           t(:arglist,
+                             t(:lit, 0, Type.long)),
+                           Type.bool),
+                         t(:return,
+                           t(:lit, 3, Type.long),
+
+                           Type.void),
+                         t(:return,
+                           t(:lit, 4, Type.long),
+                           Type.void),
+                         Type.void),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "if (rb_funcall(LONG2NUM(42), rb_intern(\"==\"), 1, LONG2NUM(0))) {\nreturn LONG2NUM(3);\n} else {\nreturn LONG2NUM(4);\n}",
+      "RubyToAnsiC" => "if (42 == 0) {\nreturn 3;\n} else {\nreturn 4;\n}",
+    },
+
+    "conditional4" => {
+      "Ruby"        => "if (42 == 0)
+  return 2
+else
+  if (42 < 0)
+    return 3
+  else
+    return 4
+  end
+end",
+      "ParseTree"   => [:if,
+        [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
+        [:return, [:lit, 2]],
+        [:if,
+          [:call, [:lit, 42], :<, [:array, [:lit, 0]]],
+          [:return, [:lit, 3]],
+          [:return, [:lit, 4]]]],
+      "Rewriter"    => s(:if,
+                         s(:call,
+                           s(:lit, 42),
+                           :==,
+                           s(:arglist, s(:lit, 0))),
+                         s(:return, s(:lit, 2)),
+                         s(:if,
+                           s(:call,
+                             s(:lit, 42),
+                             :<,
+                             s(:arglist, s(:lit, 0))),
+                           s(:return, s(:lit, 3)),
+                           s(:return, s(:lit, 4)))),
+      "TypeChecker" => t(:if,
+                         t(:call,
+                           t(:lit, 42, Type.long),
+                           :==,
+                           t(:arglist,
+                             t(:lit, 0, Type.long)),
+                           Type.bool),
+                         t(:return,
+                           t(:lit, 2, Type.long),
+                           Type.void),
+                         t(:if,
+                           t(:call,
+                             t(:lit, 42, Type.long),
+                             :<,
+                             t(:arglist,
+                               t(:lit, 0, Type.long)),
+                             Type.bool),
+                           t(:return,
+                             t(:lit, 3, Type.long),
+                             Type.void),
+                           t(:return,
+                             t(:lit, 4, Type.long),
+                             Type.void),
+                           Type.void),
+                         Type.void),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "if (rb_funcall(LONG2NUM(42), rb_intern(\"==\"), 1, LONG2NUM(0))) {\nreturn LONG2NUM(2);\n} else {\nif (rb_funcall(LONG2NUM(42), rb_intern(\"<\"), 1, LONG2NUM(0))) {\nreturn LONG2NUM(3);\n} else {\nreturn LONG2NUM(4);\n}\n}",
+      "RubyToAnsiC" => "if (42 == 0) {\nreturn 2;\n} else {\nif (42 < 0) {\nreturn 3;\n} else {\nreturn 4;\n}\n}",
+    },
+
+    "defn_bmethod_added" => {
+      "Ruby"        => "def bmethod_added(x)\n  x + 1\nend",
+      "ParseTree"   => [:defn, :bmethod_added,
+        [:bmethod,
+          [:dasgn_curr, :x],
+          [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
+      "Rewriter" => s(:defn,
+                      :bmethod_added,
+                      s(:args, :x),
+                      s(:scope,
+                        s(:block,
+                          s(:call, s(:lvar, :x), :+, s(:arglist, s(:lit, 1)))))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "defn_empty" => {
+      "Ruby"        => "def empty()\n  nil\nend",
+      "ParseTree"   => [:defn, :empty, [:scope, [:block, [:args], [:nil]]]],
+      "Rewriter"    => s(:defn, :empty,
+                         s(:args), s(:scope, s(:block, s(:nil)))),
+      "TypeChecker" => t(:defn, :empty,
+                         t(:args),
+                         t(:scope,
+                           t(:block,
+                             t(:nil, Type.value),
+                             Type.unknown),
+                           Type.void),
+                         Type.function(Type.unknown, [], Type.void)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE\nrrc_c_empty(VALUE self) {\nQnil;\n}",
+      "RubyToAnsiC" => "void\nempty() {\nNULL;\n}",
+    },
+
+    "defn_zarray" => {
+      "Ruby"        => "def empty()\n  a = []\n  return a\nend",
+      "ParseTree"   => [:defn, :empty, [:scope, [:block, [:args], [:lasgn, :a, [:zarray]], [:return, [:lvar, :a]]]]],
+      "Rewriter"    => s(:defn,
+                         :empty,
+                         s(:args),
+                         s(:scope, s(:block, s(:lasgn, :a, s(:array)), s(:return, s(:lvar, :a))))),
+      "TypeChecker" => t(:defn,
+                         :empty,
+                         t(:args),
+                         t(:scope,
+                           t(:block,
+                             t(:lasgn, :a, t(:array), Type.unknown_list),
+                             t(:return,
+                               t(:lvar,
+                                 :a, Type.unknown_list), Type.void),
+                             Type.unknown), Type.void),
+                         Type.function(Type.unknown, [], Type.unknown_list)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE\nrrc_c_empty(VALUE self) {\nVALUE a;\na = rb_ary_new2(0);\nreturn a;\n}",
+      "RubyToAnsiC" => "void *\nempty() {\nvoid * a;\na = (void *) malloc(sizeof(void *) * 0);\nreturn a;\n}",
+    },
+
+    "defn_or" => {
+      "Ruby"        => "def |()\n  nil\nend",
+      "ParseTree"   => [:defn, :|, [:scope, [:block, [:args], [:nil]]]],
+      "Rewriter"    => s(:defn, :|,
+                         s(:args), s(:scope, s(:block, s(:nil)))),
+      "TypeChecker" => t(:defn, :|,
+                         t(:args),
+                         t(:scope,
+                           t(:block,
+                             t(:nil, Type.value),
+                             Type.unknown),
+                           Type.void),
+                         Type.function(Type.unknown, [], Type.void)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE\nrrc_c_or(VALUE self) {\nQnil;\n}",
+      "RubyToAnsiC" => "void\nor() {\nNULL;\n}",
+    },
+
+    "defn_is_something" => {
+      "Ruby"        => "def something?()\n  nil\nend",
+      "ParseTree"   => [:defn, :something?, [:scope, [:block, [:args], [:nil]]]],
+      "Rewriter"    => s(:defn, :something?,
+                         s(:args), s(:scope, s(:block, s(:nil)))),
+      "TypeChecker" => t(:defn, :something?,
+                         t(:args),
+                         t(:scope,
+                           t(:block,
+                             t(:nil, Type.value),
+                             Type.unknown),
+                           Type.void),
+                         Type.function(Type.unknown, [], Type.void)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE\nrrc_c_is_something(VALUE self) {\nQnil;\n}",
+      "RubyToAnsiC" => "void\nis_something() {\nNULL;\n}",
+    },
+
+    "defn_fbody" => {
+      "Ruby"        => "def aliased()\n  puts(42)\nend",
+      "ParseTree" => [:defn, :aliased,
+                       [:fbody,
+                       [:scope,
+                         [:block,
+                           [:args],
+                           [:fcall, :puts, [:array, [:lit, 42]]]]]]],
+      "Rewriter"    => s(:defn, :aliased,
+                         s(:args),
+                         s(:scope,
+                           s(:block,
+                             s(:call, nil, :puts, s(:arglist, s(:lit, 42)))))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "defn_optargs" => {
+      "Ruby"        => "def x(a, *args)\n  p(a, args)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :"*args"],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :args]]]]]],
+      "Rewriter"    => s(:defn, :x,
+                         s(:args, :a, :"*args"),
+                         s(:scope,
+                           s(:block,
+                             s(:call, nil, :p,
+                               s(:arglist, s(:lvar, :a), s(:lvar, :args)))))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "dmethod_added" => {
+      "Ruby"        => "def dmethod_added\n  define_method(:bmethod_added)\n  x {|(x + 1)|\n  }end",
+      "ParseTree"   => [:defn,
+        :dmethod_added,
+        [:dmethod,
+          :bmethod_maker,
+          [:scope,
+            [:block,
+              [:args],
+              [:iter,
+                [:fcall, :define_method, [:array, [:lit, :bmethod_added]]],
+                [:dasgn_curr, :x],
+                [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]],
+      "Rewriter" => s(:defn,
+                      :dmethod_added,
+                      s(:args, :x),
+                      s(:scope,
+                        s(:block,
+                          s(:call, s(:lvar, :x), :+,
+                            s(:arglist, s(:lit, 1)))))),
+      "TypeChecker" => :skip,
+      "CRewriter" => :skip,
+      "RubyToRubyC" => :skip,
+      "RubyToAnsiC" => :skip,
+    },
+
+    "global" => {
+      "Ruby"        => "$stderr",
+      "ParseTree"   =>  [:gvar, :$stderr],
+      "Rewriter"    => s(:gvar, :$stderr),
+      # TODO: test s(:gvar, :$stderr) != t(:gvar, $stderr, Type.file)
+      "TypeChecker" => t(:gvar, :$stderr, Type.file),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "rb_gv_get(\"$stderr\")",
+      "RubyToAnsiC" => "stderr",
+    },
+
+    "interpolated" => {
+      "Ruby"        => "\"var is \#{argl}. So there.\"",
+      "ParseTree"   => [:dstr,
+        "var is ", [:lvar, :argl], [:str, ". So there."]],
+      "Rewriter" => s(:dstr,
+                      "var is ", s(:lvar, :argl), s(:str, ". So there.")),
+      "TypeChecker" => t(:dstr,
+                         "var is ",
+                             t(:lvar, :argl, Type.long),
+                             t(:str, ". So there.", Type.str),
+                             Type.str),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "rb_funcall(rb_mKernel, rb_intern(\"sprintf\"), 4, rb_str_new2(\"%s%s%s\"), rb_str_new2(\"var is \"), argl, rb_str_new2(\". So there.\"))",
+      "RubyToAnsiC" => :unsupported,
+    },
+
+    "iter" => {
+      "Ruby"        => "loop do end",
+      "ParseTree"   => [:iter, [:fcall, :loop], nil],
+      "Rewriter"    => s(:iter,
+                         s(:call, nil, :loop, nil),
+                         s(:dasgn_curr, :temp_1),
+                         nil),
+      "TypeChecker" => t(:iter,
+                         t(:call, nil, :loop, nil, Type.unknown),
+                         t(:dasgn_curr, :temp_1, Type.unknown),
+                         nil,
+                         Type.unknown),
+      "CRewriter" => [:defx,
+                      t(:iter,
+                       t(:call, nil, :loop, nil, Type.unknown),
+                       t(:args,
+                         t(:array, t(:dasgn_curr, :temp_1, Type.unknown), Type.void),
+                         t(:array, Type.void), Type.void),
+                        t(:call, nil,
+                          :temp_2,
+                          s(:arglist, s(:dasgn_curr, :temp_1, Type.unknown),
+                            t(:nil)))),
+                      [t(:defx,
+                         :temp_2,
+                         t(:args, :temp_2, :temp_3),
+                         t(:scope, t(:block, nil)), Type.void)]],
+      "RubyToRubyC" => "",
+      "RubyToAnsiC" => "",
+    },
+
+    "iteration2" => {
+      "ParseTree"   => [:iter,
+        [:call, [:lvar, :arrays], :each],
+        [:dasgn_curr, :x],
+        [:fcall, :puts, [:arrays, [:dvar, :x]]]],
+      "Rewriter" => s(:iter,
+                      s(:call, s(:lvar, :arrays), :each, nil),
+                      s(:dasgn_curr, :x),
+                      s(:call, nil, :puts, s(:arglist, s(:dvar, :x)))),
+      "TypeChecker" => t(:iter,
+                         t(:call,
+                           t(:lvar, :arrays, Type.str_list),
+                           :each,
+                           nil, Type.unknown),
+                         t(:dasgn_curr, :x, Type.str),
+                         t(:call, nil, :puts,
+                           t(:arglist, t(:dvar, :x, Type.str)),
+                           Type.void),
+                         Type.void),
+       "CRewriter" => [:defx,
+                       t(:iter,
+                         t(:call,
+                           t(:lvar, :arrays, Type.str_list),
+                           :each,
+                           nil, Type.unknown),
+                         t(:args,
+                           t(:array, t(:dasgn_curr, :x, Type.str), Type.void),
+                           t(:array, t(:lvar, :arrays, Type.value), Type.void), Type.void),
+                         t(:call, nil, :temp_1, t(:arglist, t(:dasgn_curr, :x, Type.str), t(:nil)))),
+                       [t(:defx,
+                          :temp_1,
+                          t(:args, :temp_2, :temp_3),
+                          t(:scope,
+                            t(:block,
+                              t(:call,
+                                nil,
+                                :puts,
+                                t(:arglist, t(:dvar, :x, Type.str)), Type.void))), Type.void)]],
+      "RubyToRubyC" => 'unsigned long index_temp_1;
+VALUE temp_2 = rb_funcall(arrays, rb_intern("to_a"), 0);
+unsigned long temp_1_max = FIX2LONG(rb_funcall(temp_2, rb_intern("size"), 0));
+for (index_temp_1 = 0; index_temp_1 < temp_1_max; ++index_temp_1) {
+VALUE x;
+x = rb_funcall(temp_2, rb_intern("at"), 1, LONG2FIX(index_temp_1));
+rb_funcall(self, rb_intern("puts"), 1, x);
+}",
+      "RubyToAnsiC" => "unsigned long index_x;
+for (index_x = 0; arrays[index_x] != NULL; ++index_x) {
+str x = arrays[index_x];
+puts(x);
+}',
+    },
+
+
+    "iteration4" => {
+      "Ruby"        => "1.upto(3) {|n|\n  puts(n.to_s)\n}",
+      "ParseTree"   => [:iter,
+        [:call, [:lit, 1], :upto, [:array, [:lit, 3]]],
+        [:dasgn_curr, :n],
+        [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]],
+      "Rewriter" => s(:dummy,
+                      s(:lasgn, :n, s(:lit, 1)),
+                      s(:while,
+                        s(:call, s(:lvar, :n), :<=, s(:arglist, s(:lit, 3))),
+                        s(:block,
+                          s(:call,
+                            nil,
+                            :puts,
+                            s(:arglist, s(:call, s(:lvar, :n), :to_s, nil))),
+                          s(:lasgn, :n,
+                            s(:call, s(:lvar, :n),
+                              :+,
+                              s(:arglist, s(:lit, 1))))), true)),
+      "TypeChecker" => t(:dummy, t(:lasgn, :n, t(:lit, 1, Type.long), Type.long),
+                         t(:while,
+                           t(:call,
+                             t(:lvar, :n, Type.long),
+                             :<=,
+                             t(:arglist, t(:lit, 3, Type.long)), Type.bool),
+                           t(:block,
+                             t(:call, nil, :puts,
+                               t(:arglist,
+                                 t(:call,
+                                   t(:lvar, :n, Type.long),
+                                   :to_s,
+                                   nil, Type.str)), Type.void),
+                             t(:lasgn, :n,
+                               t(:call,
+                                 t(:lvar, :n, Type.long),
+                                 :+,
+                                 t(:arglist,
+                                   t(:lit,
+                                     1, Type.long)),
+                                 Type.long), Type.long), Type.unknown), true)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => '',
+      "RubyToAnsiC" => 'n = 1;
+while (n <= 3) {
+puts(to_s(n));
+n = n + 1;
+}',
+    },
+
+    "iteration5" => {
+      "Ruby"        => "3.downto(1) {|n|\n  puts(n.to_s)\n}",
+      "ParseTree"   => [:iter,
+        [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
+        [:dasgn_curr, :n],
+        [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]],
+      "Rewriter" => s(:dummy, s(:lasgn, :n, s(:lit, 3)), s(:while,
+                      s(:call, s(:lvar, :n), :>=, s(:arglist, s(:lit, 1))),
+                      s(:block,
+                        s(:call, nil, :puts,
+                          s(:arglist, s(:call, s(:lvar, :n), :to_s, nil))),
+                        s(:lasgn, :n, s(:call, s(:lvar, :n),
+                                        :-, s(:arglist, s(:lit, 1))))), true)),
+      "TypeChecker" => t(:dummy,
+                         t(:lasgn, :n, t(:lit, 3, Type.long), Type.long),
+                         t(:while,
+                           t(:call,
+                             t(:lvar, :n, Type.long),
+                             :>=,
+                             t(:arglist, t(:lit, 1, Type.long)), Type.bool),
+                           t(:block,
+                             t(:call, nil, :puts,
+                               t(:arglist,
+                                 t(:call,
+                                   t(:lvar, :n, Type.long),
+                                   :to_s,
+                                   nil, Type.str)), Type.void),
+                             t(:lasgn, :n,
+                               t(:call,
+                                 t(:lvar, :n, Type.long),
+                                 :-,
+                                 t(:arglist, t(:lit, 1, Type.long)),
+                                 Type.long),
+                               Type.long),
+                           Type.unknown), true)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => '',
+      "RubyToAnsiC" => 'n = 3;
+while (n >= 1) {
+puts(to_s(n));
+n = n - 1;
+}',
+    },
+
+    "iteration6" => {
+      "Ruby"        => "while ((argl >= (1))) do\nputs((\"hello\"))\nargl = (argl - (1))\n\nend",
+      "ParseTree"   => [:while, [:call, [:lvar, :argl],
+                        :>=, [:arglist, [:lit, 1]]], [:block,
+                        [:call, nil, :puts, [:arglist, [:str, "hello"]]],
+                        [:lasgn,
+                          :argl,
+                          [:call, [:lvar, :argl],
+                            :-, [:arglist, [:lit, 1]]]]], true],
+      "Rewriter" => s(:while,
+                      s(:call, s(:lvar, :argl),
+                        :>=, s(:arglist, s(:lit, 1))),
+                      s(:block,
+                        s(:call, nil, :puts, s(:arglist, s(:str, "hello"))),
+                        s(:lasgn,
+                          :argl,
+                          s(:call, s(:lvar, :argl),
+                            :-, s(:arglist, s(:lit, 1))))), true),
+      "TypeChecker" => t(:while,
+                         t(:call, t(:lvar, :argl, Type.long),
+                           :>=,
+                           t(:arglist, t(:lit, 1, Type.long)), Type.bool),
+                         t(:block,
+                           t(:call, nil, :puts,
+                             t(:arglist, t(:str, "hello", Type.str)),
+                             Type.void),
+                           t(:lasgn,
+                             :argl,
+                             t(:call, t(:lvar, :argl, Type.long),
+                               :-,
+                               t(:arglist, t(:lit, 1, Type.long)), Type.long),
+                             Type.long),
+                           Type.unknown), true),
+      "CRewriter" => :same,
+      "RubyToRubyC" => '',
+      "RubyToAnsiC" => 'while (argl >= 1) {
+puts("hello");
+argl = argl - 1;
+}',
+    },
+
+    # TODO: this might still be too much
+    "lasgn_call" => {
+      "Ruby"        => "c = 2 + 3",
+      "ParseTree"   => [:lasgn, :c, [:call, [:lit, 2], :+, [:arglist, [:lit, 3]]]],
+      "Rewriter"    => s(:lasgn, :c, s(:call, s(:lit, 2), :+, s(:arglist, s(:lit, 3)))),
+      "TypeChecker" => t(:lasgn, :c,
+                         t(:call,
+                           t(:lit, 2, Type.long),
+                           :+,
+                           t(:arglist,
+                             t(:lit, 3, Type.long)),
+                           Type.long),
+                         Type.long),
+      "CRewriter" => :same,
+      "RubyToRubyC" => 'c = rb_funcall(LONG2NUM(2), rb_intern("+"), 1, LONG2NUM(3))', # FIX: probably not "c ="
+      "RubyToAnsiC" => "c = 2 + 3",
+    },
+
+    "lasgn_array" => {
+      "Ruby"        => "var = [\"foo\", \"bar\"]",
+      "ParseTree"   => [:lasgn, :var, [:array,
+                                         [:str, "foo"],
+                                         [:str, "bar"]]],
+      "Rewriter"    => s(:lasgn, :var, s(:array,
+                                         s(:str, "foo"),
+                                         s(:str, "bar"))),
+      "TypeChecker" => t(:lasgn,
+                         :var,
+                         t(:array,
+                           t(:str, "foo", Type.str),
+                           t(:str, "bar", Type.str)),
+                         Type.str_list),
+      "CRewriter" => :same,
+      "RubyToRubyC" => 'var = rb_ary_new2(2);
+rb_ary_store(var, 0, rb_str_new2("foo"));
+rb_ary_store(var, 1, rb_str_new2("bar"))',
+      "RubyToAnsiC" => 'var = (str) malloc(sizeof(str) * 2);
+var[0] = "foo";
+var[1] = "bar"'
+},
+
+    "lit_bool_false" => {
+      "Ruby"        => "false",
+      "ParseTree"   => [:false],
+      "Rewriter"    => s(:false),
+      "TypeChecker" => t(:false, Type.bool),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "Qfalse",
+      "RubyToAnsiC" => "0",
+    },
+
+    "lit_bool_true" => {
+      "Ruby"        => "true",
+      "ParseTree"   => [:true],
+      "Rewriter"    => s(:true),
+      "TypeChecker" => t(:true, Type.bool),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "Qtrue",
+      "RubyToAnsiC" => "1",
+    },
+
+    "lit_float" => {
+      "Ruby"        => "1.1",
+      "ParseTree"   => [:lit, 1.1],
+      "Rewriter"    => s(:lit, 1.1),
+      "TypeChecker" => t(:lit, 1.1, Type.float),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "rb_float_new(1.1)",
+      "RubyToAnsiC" => "1.1",
+    },
+
+    "lit_long" => {
+      "Ruby"        => "1",
+      "ParseTree"   => [:lit, 1],
+      "Rewriter"    => s(:lit, 1),
+      "TypeChecker" => t(:lit, 1, Type.long),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "LONG2NUM(1)",
+      "RubyToAnsiC" => "1",
+    },
+
+    "lit_sym" => {
+      "Ruby"        => ":x",
+      "ParseTree"   => [:lit, :x],
+      "Rewriter"    => s(:lit, :x),
+      "TypeChecker" => t(:lit, :x, Type.symbol),
+      "CRewriter" => :same,
+      "RubyToRubyC" => 'ID2SYM(rb_intern("x"))',
+      "RubyToAnsiC" => '"x"', # HACK WRONG! (or... is it?)
+    },
+
+    "lit_str" => {
+      "Ruby"        => "\"x\"",
+      "ParseTree"   => [:str, "x"],
+      "Rewriter"    => s(:str, "x"),
+      "TypeChecker" => t(:str, "x", Type.str),
+      "CRewriter" => :same,
+      "RubyToRubyC" => 'rb_str_new2("x")',
+      "RubyToAnsiC" => '"x"',
+    },
+
+    "multi_args" => {
+      "Ruby"        => "def multi_args(arg1, arg2)\n  arg3 = ((arg1 * arg2) * 7)\n  puts(arg3.to_s)\n  return \"foo\"\nend",
+      "ParseTree"   => [:defn, :multi_args,
+        [:scope,
+          [:block,
+            [:args, :arg1, :arg2],
+            [:lasgn,
+              :arg3,
+              [:call,
+                [:call, [:lvar, :arg1], :*, [:array, [:lvar, :arg2]]],
+                :*,
+                [:array, [:lit, 7]]]],
+            [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+            [:return, [:str, "foo"]]]]],
+      "Rewriter" => s(:defn, :multi_args,
+                      s(:args, :arg1, :arg2),
+                      s(:scope,
+                        s(:block,
+                          s(:lasgn, :arg3,
+                            s(:call,
+                              s(:call,
+                                s(:lvar, :arg1),
+                                :*,
+                                s(:arglist, s(:lvar, :arg2))),
+                              :*,
+                              s(:arglist, s(:lit, 7)))),
+                          s(:call,
+                            nil,
+                            :puts,
+                            s(:arglist,
+                              s(:call,
+                                s(:lvar, :arg3),
+                                :to_s,
+                                nil))),
+                          s(:return, s(:str, "foo"))))),
+      "TypeChecker" => t(:defn, :multi_args,
+                   t(:args,
+                     t(:arg1, Type.long),
+                     t(:arg2, Type.long)),
+                   t(:scope,
+                     t(:block,
+                       t(:lasgn,
+                         :arg3,
+                         t(:call,
+                           t(:call,
+                             t(:lvar, :arg1, Type.long),
+                             :*,
+                             t(:arglist,
+                               t(:lvar,
+                                 :arg2,
+                                 Type.long)),
+                             Type.long),
+                           :*,
+                           t(:arglist,
+                             t(:lit, 7, Type.long)),
+                           Type.long),
+                         Type.long),
+                       t(:call,
+                         nil,
+                         :puts,
+                         t(:arglist,
+                           t(:call,
+                             t(:lvar, :arg3, Type.long),
+                             :to_s,
+                             nil,
+                             Type.str)),
+                         Type.void),
+                       t(:return, t(:str, "foo", Type.str),
+                         Type.void),
+                       Type.unknown),
+                     Type.void),
+                   Type.function(Type.unknown,
+                                 [Type.long, Type.long], Type.str)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE
+rrc_c_multi_args(VALUE self, VALUE arg1, VALUE arg2) {
+VALUE arg3;
+arg3 = rb_funcall(rb_funcall(arg1, rb_intern(\"*\"), 1, arg2), rb_intern(\"*\"), 1, LONG2NUM(7));
+rb_funcall(self, rb_intern(\"puts\"), 1, rb_funcall(arg3, rb_intern(\"to_s\"), 0));
+return rb_str_new2(\"foo\");
+}",
+      "RubyToAnsiC" => "str
+multi_args(long arg1, long arg2) {
+long arg3;
+arg3 = arg1 * arg2 * 7;
+puts(to_s(arg3));
+return \"foo\";
+}",
+    },
+ 
+    "vcall" => {
+      "Ruby"        => "method",
+      "ParseTree"   => [:vcall, :method],
+      "Rewriter"    => s(:call, nil, :method, nil),
+      "TypeChecker" => t(:call, nil, :method, nil, Type.unknown),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "rb_funcall(self, rb_intern(\"method\"), 0)",
+      "RubyToAnsiC" => "method()",
+    },
+
+    "whiles" => {
+      "Ruby"        => "def whiles()\n  while (false) do\n    puts(\"false\")\n  end\n  begin\n    puts(\"true\")\n  end while (false)\nend",
+      "ParseTree"   => [:defn,
+        :whiles,
+        [:scope,
+          [:block,
+            [:args],
+            [:while, [:false],
+              [:fcall, :puts, [:array, [:str, "false"]]], true],
+            [:while, [:false],
+              [:fcall, :puts, [:array, [:str, "true"]]], false]]]],
+      "Rewriter" => s(:defn,
+               :whiles,
+               s(:args),
+               s(:scope,
+                 s(:block,
+                   s(:while,
+                     s(:false),
+                     s(:call, nil, :puts, s(:arglist, s(:str, "false"))),
+                     true),
+                   s(:while,
+                     s(:false),
+                     s(:call, nil, :puts, s(:arglist, s(:str, "true"))),
+                     false)))),
+      "TypeChecker" => t(:defn,
+               :whiles,
+               t(:args),
+               t(:scope,
+                 t(:block,
+                   t(:while,
+                     t(:false, Type.bool),
+                     t(:call,
+                       nil,
+                       :puts,
+                       t(:arglist, t(:str, "false", Type.str)), Type.void),
+                     true),
+                   t(:while,
+                     t(:false, Type.bool),
+                     t(:call,
+                       nil,
+                       :puts,
+                       t(:arglist, t(:str, "true", Type.str)), Type.void),
+                     false),
+                   Type.unknown),
+                 Type.void),
+               Type.function(Type.unknown, [], Type.void)),
+      "CRewriter" => :same,
+      "RubyToRubyC" => "static VALUE
+rrc_c_whiles(VALUE self) {
+while (Qfalse) {
+rb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"false\"));
+};
+{
+rb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"true\"));
+} while (Qfalse);
+}",
+      "RubyToAnsiC" => "void
+whiles() {
+while (0) {
+puts(\"false\");
+};
+{
+puts(\"true\");
+} while (0);
+}",
+    },
+
+    "zarray" => {
+      "Ruby"        => "a = []",
+      "ParseTree"   => [:lasgn, :a, [:zarray]],
+      "Rewriter" => s(:lasgn, :a, s(:array)),
+      "TypeChecker" => t(:lasgn, :a, t(:array), Type.unknown_list),
+      "CRewriter" => :same,
+      # TODO: need to verify that our variable decl will be correct
+      "RubyToRubyC" => "a = rb_ary_new2(0)",
+      "RubyToAnsiC" => "a = (void *) malloc(sizeof(void *) * 0)",
+    },
+  }
+
+  def self.previous(key)
+    idx = @@testcase_order.index(key)-1
+    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)
+    self.clone_same
+
+    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 data[input_name] == :skip
+      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"
+        assert data.has_key?(output_name), "Unknown expected data"
+        input = data[input_name].deep_clone
+        expected = data[output_name].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
+          
+          assert_equal expected, processor.process(input)
+          extra_input.each do |input| processor.process(input) end
+          extra = processor.extra_methods rescue []
+          assert_equal extra_expected, extra
+        end
+      end
+    end
+  end
+
+  def test_stoopid
+    # do nothing - shuts up empty test class requirement
+  end
+
+end