ruby2c 1.0.0.6

data/test/test_ruby_to_ruby_c.rb

@@ -0,0 +1,161 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'minitest/autorun' if $0 == __FILE__
+require 'ruby_to_ruby_c'
+require 'r2ctestcase'
+require 'unique'
+
+class TestRubyToRubyC < R2CTestCase
+
+  def setup
+    @ruby_to_c = RubyToRubyC.new
+    @ruby_to_c.env.extend
+    @processor = @ruby_to_c
+    Unique.reset
+  end
+
+  def test_process_dstr
+    input  = t(:dstr,
+               "var is ",
+               t(:lit, 42, Type.long),
+               t(:str, ". So there.", Type.str), Type.str)
+    output = 'rb_funcall(rb_mKernel, rb_intern("sprintf"), 4, rb_str_new2("%s%s%s"), rb_str_new2("var is "), LONG2NUM(42), rb_str_new2(". So there."))'
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_dxstr
+    input  = t(:dxstr,
+               "touch ",
+               t(:lvar, :x, Type.str), Type.str)
+    output = 'rb_funcall(rb_mKernel, rb_intern("`"), 1, rb_funcall(rb_mKernel, rb_intern("sprintf"), 3, rb_str_new2("%s%s"), rb_str_new2("touch "), x))'
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_float
+    input  = t(:lit, 1.0, Type.float)
+    output = "rb_float_new(1.0)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_iter
+    # ruby: arrays.each { ... }
+    input = t(:iter,
+              t(:call,
+                t(:lvar, :arrays, Type.str_list), # should register static
+                :each,
+                nil, Type.unknown),
+              t(:args,
+                t(:array, t(:lvar, :arrays, Type.value), Type.void),
+                t(:array, t(:lvar, :static_temp_4, Type.value), Type.void),
+                Type.void),
+              :temp_1)
+    output = "static_temp_4 = arrays;
+rb_iterate(rb_each, arrays, temp_1, Qnil);
+arrays = static_temp_4;"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_defx
+    # ruby: this is the ... from arrays.each { ... } 
+    input = t(:defx,
+              :temp_1,
+              t(:args,
+                t(:temp_2, Type.str),
+                t(:temp_3, Type.value)),
+              t(:scope,
+                t(:block,
+                  t(:lasgn,
+                    :arrays,
+                    t(:lvar, :static_arrays, Type.value),
+                    Type.value),
+                  t(:lasgn, :x, t(:lvar, :temp_2, Type.str),
+                    Type.str),
+                  t(:call,
+                    nil,
+                    :puts,
+                    t(:arglist, t(:dvar, :x, Type.str)), Type.void),
+                  t(:lasgn,
+                    :static_arrays,
+                    t(:lvar, :arrays, Type.value),
+                    Type.value),
+                  t(:return, t(:nil, Type.value)))), Type.void)
+
+    output = "static VALUE
+rrc_c_temp_1(VALUE temp_2, VALUE temp_3) {
+VALUE arrays;
+VALUE x;
+arrays = static_arrays;
+x = temp_2;
+rb_funcall(self, rb_intern(\"puts\"), 1, x);
+static_arrays = arrays;
+return Qnil;
+}"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_long
+    input  = t(:lit, 1, Type.long)
+    output = "LONG2NUM(1)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_range
+    input  = t(:lit, 1..42, Type.range)
+    output = "rb_range_new(LONG2NUM(1), LONG2NUM(42), 0)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_range_exc
+    input  = t(:lit, 1...42, Type.range)
+    output = "rb_range_new(LONG2NUM(1), LONG2NUM(42), 1)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_regexp
+    input  = t(:lit, /x/, Type.regexp)
+    output = "rb_reg_new(\"x\", 1, 0)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_regexp_i
+    input  = t(:lit, /x|y/i, Type.regexp)
+    output = "rb_reg_new(\"x|y\", 3, 1)"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_lit_sym
+    input  = t(:lit, :sym, Type.symbol)
+    output = "ID2SYM(rb_intern(\"sym\"))"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_xstr
+    input  = t(:xstr, 'touch 5', Type.str)
+    output = 'rb_funcall(rb_mKernel, rb_intern("`"), 1, rb_str_new2("touch 5"))'
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+#   def test_translator
+#     Object.class_eval "class Suck; end"
+#     input = [:class, :Suck, :Object,
+#       [:defn, :something, [:scope, [:block, [:args], [:fcall, :"whaaa\?"]]]],
+#       [:defn, :foo, [:scope, [:block, [:args], [:vcall, :something]]]]]
+#     expected = "// class Suck < Object\n\nstatic VALUE\nrrc_c_something(VALUE self) {\nrb_funcall(self, rb_intern(\"whaaa?\"), 0);\n}\n\nstatic VALUE\nrrc_c_foo(VALUE self) {\nrb_funcall(self, rb_intern(\"something\"), 0);\n}"
+#     assert_equal expected, RubyToRubyC.translator.process(input)
+#   end
+
+end

data/test/test_type.rb

@@ -0,0 +1,193 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'minitest/autorun' if $0 == __FILE__
+require 'minitest/unit'
+require 'type'
+require 'sexp_processor' # for deep clone FIX ?
+
+class TestType < MiniTest::Unit::TestCase
+  def setup
+    @unknown = Type.unknown
+    @unknown_list = Type.unknown_list
+    @long = Type.long
+    @long_list = Type.new(:long, true)
+  end
+
+  def test_function?
+    assert ! @long.function?
+    assert ! @long_list.function?
+    assert ! @unknown.function?
+    assert ! @unknown_list.function?
+    assert Type.function(Type.str, [Type.str], Type.str).function?
+  end
+
+  def test_list
+    assert_equal false, @long.list
+    assert_equal true, @long_list.list
+  end
+
+  def test_list=
+    long = Type.long.deep_clone
+    long_list = Type.long_list.deep_clone
+
+    long.list = true
+    long_list.list = false
+
+    assert_equal true, long.list
+    assert_equal false, long_list.list
+  end
+
+  def test_type
+    assert_kind_of Handle, @long.type
+    assert_equal :long, @long.type.contents
+  end
+
+  def test_type_good
+    file = Type.file
+    assert_kind_of Type, file
+    assert_equal :file, file.type.contents
+  end
+
+  def test_type_bad
+    assert_raises(RuntimeError) do
+      Type.blahblah
+    end
+  end
+
+  def test_type=
+    long = Type.long.deep_clone
+    long.type = "something"
+    assert_equal "something", long.type
+  end
+
+  def test_unknown_types
+    assert_raises(RuntimeError) do
+      Type.new(:some_made_up_type)
+    end
+
+    assert_raises(RuntimeError) do
+      Type.some_made_up_type
+    end
+  end
+
+  def test_function
+    # TODO: actually TEST something here
+    Type.function([Type.unknown], Type.unknown)
+  end
+
+  def test_list_type
+    assert_equal :long, @long_list.list_type
+  end
+
+  def test_equals
+    type = Type.long
+    refute_equal @unknown, type
+    assert_equal @long, type
+    refute_equal @long_list, type
+  end
+
+  def test_hash
+    long1 = Type.long
+    long2 = Type.long
+
+    a = Type.unknown
+    a.unify long1
+
+    b = Type.unknown
+    b.unify long2
+
+    assert a == b, "=="
+    assert a === b, "==="
+    assert a.eql?(b), ".eql?"
+    assert_equal a.hash, b.hash, "hash"
+
+    assert_equal 1, [a, b].uniq.size
+  end
+
+  def test_list_equal
+    type = Type.new(:long, true)
+    refute_equal @unknown, type
+    refute_equal @long, type
+    assert_equal @long_list, type
+  end
+
+  def test_to_s
+    assert_equal "Type.long", @long.to_s
+    assert_equal "Type.long_list", @long_list.to_s
+  end
+
+  def test_unknown?
+    assert_equal Type.unknown, Type.unknown
+    refute_same Type.unknown, Type.unknown
+  end
+
+  def test_unknown_list
+    assert_equal @unknown_list, Type.unknown_list
+    refute_same Type.unknown_list, Type.unknown_list
+    assert @unknown_list.list?
+  end
+
+  def test_unify_fail
+    long = Type.new(:long)
+    string = Type.new(:str)
+    long_list = Type.new(:long, true)
+
+    assert_raises(TypeError) do
+      long.unify string
+    end
+
+    assert_raises(TypeError) do
+      long.unify long_list
+    end
+  end
+
+  def test_unify_simple
+    long = Type.new(:long)
+    unknown = Type.unknown
+
+    assert_equal @long, long
+
+    unknown.unify long
+
+    assert !unknown.list?
+    assert_equal long, unknown
+    assert_equal @long, unknown
+  end
+
+  def test_unify_list
+    long_list = Type.new(:long, true)
+    unknown = Type.unknown
+
+    assert_equal @long_list, long_list
+
+    unknown.unify long_list
+
+    assert unknown.list?
+    assert_equal long_list, unknown
+    assert_equal @long_list, unknown
+  end
+
+  def test_unify_link
+    unknown1 = Type.unknown
+    unknown2 = Type.unknown
+    long = Type.new(:long)
+
+    unknown1.unify unknown2
+    assert_same(unknown1.type, unknown2.type,
+                "Type of unified unknowns must be identical")
+
+    long.unify unknown2
+    assert_equal(long, unknown2)
+    assert_equal(long, unknown1,
+                 "Type unified across all linked Types")
+  end
+
+  def test_unify_function
+    fun = Type.function [Type.unknown], Type.unknown
+    @unknown.unify fun
+    assert_equal fun, @unknown
+  end
+
+end

data/test/test_type_checker.rb

@@ -0,0 +1,805 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'minitest/autorun' if $0 == __FILE__
+require 'type_checker'
+require 'r2ctestcase'
+
+class DumbClass # ZenTest SKIP
+  def empty
+  end
+end
+
+class X # ZenTest SKIP
+  VALUE = 42
+end
+
+class TestTypeChecker < R2CTestCase
+  def setup
+    @type_checker = TypeChecker.new
+    @processor = @type_checker
+    @type_checker.env.add :argl, Type.long
+    @type_checker.env.add :args, Type.str
+    @type_checker.env.add :arrayl, Type.long_list
+    @type_checker.env.add :arrayl2, Type.long_list
+    @type_checker.env.add :arrays, Type.str_list
+    @type_checker.genv.add :SyntaxError, Type.fucked
+    @type_checker.genv.add :Exception, Type.fucked
+
+    # HACK
+    @type_checker.genv.add :$stdin, Type.file
+    @type_checker.genv.add :$stdout, Type.file
+    @type_checker.genv.add :$stderr, Type.file
+  end
+
+  def test_bootstrap
+    # bootstrap is automatically called by initialize
+    # TODO should we check for EVERYTHING we expect?
+
+# HACK
+#     assert_equal Type.file, @type_checker.genv.lookup(:$stdin)
+#     assert_equal Type.file, @type_checker.genv.lookup(:$stdout)
+#     assert_equal Type.file, @type_checker.genv.lookup(:$stderr)
+
+    assert_equal(Type.function(Type.long, [Type.long], Type.bool),
+                 @type_checker.functions[:>])
+  end
+
+  def test_defn_call_unify
+    # pre-registered function, presumibly through another :call elsewhere
+    add_fake_function :specific, Type.unknown, Type.unknown, Type.unknown
+
+    # now in specific, unify with a long
+    s = @type_checker.process(s(:defn, :specific,
+                                s(:args, :x),
+                                s(:scope,
+                                  s(:block,
+                                    s(:lasgn, :x, s(:lit, 2))))))
+    s_type = @type_checker.functions[:specific]
+
+    assert_equal(Type.long,
+                 s_type.list_type.formal_types[0])
+# HACK    flunk "eric hasn't finished writing me yet. guilt. guilt. guilt."
+  end
+
+  def test_env
+    @type_checker.env.add :blah, Type.long
+    assert_equal Type.long, @type_checker.env.lookup(:blah)
+  end
+
+  def test_functions
+    # bootstrap populates functions
+    assert @type_checker.functions.has_key?(:puts)
+    assert_equal(Type.function(Type.long, [Type.long], Type.bool),
+                 @type_checker.functions[:>])
+  end
+
+# HACK
+#   def test_genv
+#     assert_equal Type.file, @type_checker.genv.lookup(:$stderr)
+#   end
+
+  def test_process_args
+    @type_checker.env.extend
+
+    input =  t(:args, :foo, :bar)
+    output = t(:args,
+               t(:foo, Type.unknown),
+               t(:bar, Type.unknown))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_args_empty
+    input =  t(:args)
+    output = t(:args)
+    # TODO: this should be superseded by the new array functionality
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_array_multiple
+    add_fake_var :arg1, Type.long
+    add_fake_var :arg2, Type.str
+
+    input =  t(:array, t(:lvar, :arg1), t(:lvar, :arg2))
+    output = t(:array,
+               t(:lvar, :arg1, Type.long),
+               t(:lvar, :arg2, Type.str))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_array_single
+    add_fake_var :arg1, Type.long
+
+    input  = t(:array, t(:lvar, :arg1))
+    output = t(:array, t(:lvar, :arg1, Type.long))
+
+    result = @type_checker.process(input)
+
+    assert_equal Type.homo, result.sexp_type
+    assert_equal [ Type.long ], result.sexp_types
+    assert_equal output, result
+  end
+
+  def test_process_block
+    input  = t(:block, t(:return, t(:nil)))
+    # FIX: should this really be void for return?
+    output = t(:block,
+               t(:return,
+                 t(:nil, Type.value),
+                 Type.void),
+               Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_block_multiple
+    input  = t(:block,
+               t(:str, :foo),
+               t(:return, t(:nil)))
+    output = t(:block,
+               t(:str, :foo, Type.str),
+               t(:return,
+                 t(:nil, Type.value),
+                 Type.void),
+               Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_case_equal_long
+    add_fake_var :number, Type.unknown
+
+    input  = t(:call,
+               t(:lit, 1),
+               :===,
+               t(:arglist, t(:lvar, :number)))
+    output = t(:call,
+               t(:lit, 1, Type.long),
+               :case_equal_long,
+               t(:arglist,
+                 t(:lvar, :number, Type.long)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_case_equal_string
+    add_fake_var :string, Type.unknown
+
+    input  = t(:call,
+               t(:str, 'foo'),
+               :===,
+               t(:arglist, t(:lvar, :string)))
+    output = t(:call,
+               t(:str, 'foo', Type.str),
+               :case_equal_str,
+               t(:arglist,
+                 t(:lvar, :string, Type.str)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_defined
+    add_fake_function :name, Type.void, Type.long, Type.str
+    input  = t(:call,
+               nil,
+               :name,
+               t(:arglist, t(:str, "foo")))
+    output = t(:call,
+               nil,
+               :name,
+               t(:arglist, t(:str, "foo", Type.str)),
+               Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_defined_rhs
+    add_fake_function :name3, Type.long, Type.long, Type.str
+    input  = t(:call,
+               t(:lit, 1),
+               :name3,
+               t(:arglist, t(:str, "foo")))
+    output = t(:call,
+               t(:lit, 1, Type.long),
+               :name3,
+               t(:arglist, t(:str, "foo", Type.str)),
+               Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_undefined
+    input  = t(:call, nil, :name, nil)
+    output = t(:call, nil, :name, nil, Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+    # FIX returns unknown in s()
+    assert_equal(Type.function(Type.unknown, [], Type.unknown),
+                 @type_checker.functions[:name])
+  end
+
+  def test_process_call_unify_1
+    add_fake_var :number, Type.long
+    input  = t(:call,
+               t(:lit, 1),
+               :==,
+               t(:arglist,
+                 t(:lvar, :number)))
+    output = t(:call,
+               t(:lit, 1, Type.long),
+               :==,
+               t(:arglist,
+                 t(:lvar, :number, Type.long)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_unify_2
+    add_fake_var :number1, Type.unknown
+    add_fake_var :number2, Type.unknown
+
+    input  = t(:call,
+               t(:lit, 1),
+               :==,
+               t(:arglist, t(:lvar, :number1)))
+    output = t(:call,
+               t(:lit, 1, Type.long),
+               :==,
+               t(:arglist,
+                 t(:lvar, :number1, Type.long)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+
+    input  = t(:call,
+               t(:lvar, :number2),
+               :==,
+               t(:arglist, t(:lit, 1)))
+    output = t(:call,
+               t(:lvar, :number2, Type.long),
+               :==,
+               t(:arglist,
+                 t(:lit, 1, Type.long)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_unify_3
+    a_type = Type.unknown
+    add_fake_var :a, a_type # TODO: Type.unknown
+
+    # def unify_3_outer(a)
+    #
+    #             unk
+    #              ^
+    #              |
+    # outer(., ., [+])
+
+    # assume the environment got everything set up correctly
+    add_fake_function(:unify_3_outer, Type.void, Type.void, a_type)
+
+    assert_equal(a_type,
+                 @type_checker.functions[:unify_3_outer].list_type.formal_types[0])
+
+    #   unify_3_inner(a) # call
+    #
+    # outer(., ., [+])
+    #              |
+    #              v
+    #             unk
+    #              ^
+    #              |
+    # inner(., ., [+])
+
+    @type_checker.process(t(:call, t(:nil),
+                            :unify_3_inner,
+                            t(:arglist, t(:lvar, :a))))
+
+    assert_equal a_type, @type_checker.env.lookup(:a)
+    assert_equal(@type_checker.env.lookup(:a),
+                 @type_checker.functions[:unify_3_inner].list_type.formal_types[0])
+
+    # def unify_3_inner(a)
+    #   a = 1
+    # end
+    #
+    # outer(., ., [+])
+    #              |
+    #              v
+    #             long
+    #              ^
+    #              |
+    # inner(., ., [+])
+
+    @type_checker.env.scope do
+      @type_checker.env.add :a, a_type
+
+      @type_checker.process t(:lasgn, :a, t(:lit, 1))
+    end
+
+    assert_equal a_type, Type.long
+
+    assert_equal(@type_checker.functions[:unify_3_inner].list_type.formal_types[0],
+                 @type_checker.functions[:unify_3_outer].list_type.formal_types[0])
+  end
+
+  # HACK: putting class X above w/ some consts
+  def test_process_class
+    input = s(:class, :X, :Object,
+              s(:defn, :meth,
+                s(:args, :x),
+                s(:scope,
+                  s(:block,
+                    s(:lasgn, :x, s(:const, :VALUE))))))
+    output = t(:class, :X, :Object,
+               t(:defn, :meth,
+                 t(:args, t(:x, Type.long)),
+                 t(:scope,
+                   t(:block,
+                     t(:lasgn, :x,
+                       t(:const, :VALUE, Type.long),
+                       Type.long),
+                     Type.unknown),
+                   Type.void),
+                 Type.function(Type.unknown, [Type.long], Type.void)),
+               Type.zclass)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_const
+    assert_raises NameError do
+      @type_checker.process s(:const, :NonExistant)
+    end
+  end
+
+  def test_process_cvar
+    input  = s(:cvar, :name)
+    output = t(:cvar, :name, Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_cvasgn
+    input  = s(:cvasgn, :name, s(:lit, 4))
+    output = t(:cvasgn, :name, t(:lit, 4, Type.long), Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_dasgn_curr
+    @type_checker.env.extend
+    input  = t(:dasgn_curr, :x)
+    output = t(:dasgn_curr, :x, Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+    # HACK: is this a valid test??? it was in ruby_to_c:
+    # assert_equal Type.long, @type_checker.env.lookup(:x)
+  end
+
+  def test_process_defn
+    function_type = Type.function s(), Type.void
+    input  = t(:defn,
+               :empty,
+               t(:args),
+               t(:scope))
+    output = t(:defn,
+               :empty,
+               t(:args),
+               t(:scope, Type.void),
+               function_type)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_dstr
+    add_fake_var :var, Type.str
+    input  = t(:dstr,
+               "var is ",
+               t(:lvar, :var),
+               t(:str, ". So there."))
+    output = t(:dstr, "var is ",
+               t(:lvar, :var, Type.str),
+               t(:str, ". So there.", Type.str),
+               Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_dvar
+    add_fake_var :dvar, Type.long
+    input  = t(:dvar, :dvar)
+    output = t(:dvar, :dvar, Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_false
+    input =   t(:false)
+    output = t(:false, Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_gasgn
+    input = s(:gasgn, :$blah, s(:lit, 42))
+    expected = t(:gasgn, :$blah, t(:lit, 42, Type.long), Type.long)
+
+    assert_equal expected, @type_checker.process(input)
+  end
+
+  def test_process_gvar_defined
+    add_fake_gvar :$arg, Type.long
+    input  = t(:gvar, :$arg)
+    output = t(:gvar, :$arg, Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_gvar_undefined
+    input  = t(:gvar, :$arg)
+    output = t(:gvar, :$arg, Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_iasgn
+    input = s(:iasgn, :@blah, s(:lit, 42))
+    expected = t(:iasgn, :@blah, t(:lit, 42, Type.long), Type.long)
+
+    assert_equal expected, @type_checker.process(input)
+  end
+
+  def test_process_if
+    input  = t(:if,
+               t(:call,
+                 t(:lit, 1),
+                 :==,
+                 t(:arglist, t(:lit, 2))),
+               t(:str, "not equal"),
+               nil)
+    output = t(:if,
+               t(:call,
+                 t(:lit, 1, Type.long),
+                 :==,
+                 t(:arglist,
+                   t(:lit, 2, Type.long)),
+                 Type.bool),
+               t(:str, "not equal", Type.str),
+               nil,
+               Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_if_else
+    input  = t(:if,
+               t(:call,
+                 t(:lit, 1),
+                 :==,
+                 t(:arglist, t(:lit, 2))),
+               t(:str, "not equal"),
+               t(:str, "equal"))
+    output = t(:if,
+               t(:call,
+                 t(:lit, 1, Type.long),
+                 :==,
+                 t(:arglist, t(:lit, 2, Type.long)),
+                 Type.bool),
+               t(:str, "not equal", Type.str),
+               t(:str, "equal", Type.str),
+               Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_iter
+    @type_checker.env.extend
+    var_type = Type.long_list
+    add_fake_var :array, var_type
+    input  = t(:iter,
+               t(:call,
+                 t(:lvar, :array),
+                 :each,
+                 nil),
+               t(:dasgn_curr, :x),
+               t(:call,
+                 nil,
+                 :puts,
+                 t(:arglist,
+                   t(:call,
+                     t(:dvar, :x),
+                     :to_s,
+                     nil))))
+    output = t(:iter,
+               t(:call,
+                 t(:lvar, :array, var_type),
+                 :each,
+                 nil,
+                 Type.unknown),
+               t(:dasgn_curr, :x, Type.long),
+               t(:call,
+                 nil,
+                 :puts,
+                 t(:arglist,
+                   t(:call,
+                     t(:dvar, :x, Type.long),
+                     :to_s,
+                     nil,
+                     Type.str)),
+                 Type.void),
+               Type.void)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_ivar
+    @type_checker.env.add :@blah, Type.long
+    input = s(:ivar, :@blah)
+    expected = t(:ivar, :@blah, Type.long)
+
+    assert_equal expected, @type_checker.process(input)
+  end
+
+  def test_process_lasgn
+    @type_checker.env.extend # FIX: this is a design flaw... examine irb sess:
+    # require 'sexp_processor'
+    # require 'type_checker'
+    # tc = TypeChecker.new
+    # s = t(:lasgn, :var, t(:str, "foo"))
+    # tc.process(s)
+    # => raises
+    # tc.env.extend
+    # tc.process(s)
+    # => raises elsewhere... etc etc etc
+    # makes debugging very difficult
+    input  = t(:lasgn, :var, t(:str, "foo"))
+    output = t(:lasgn, :var,
+               t(:str, "foo", Type.str),
+               Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lasgn_array
+    @type_checker.env.extend
+    input  = t(:lasgn,
+               :var,
+               t(:array,
+                 t(:str, "foo"),
+                 t(:str, "bar")))
+    output = t(:lasgn, :var,
+               t(:array,
+                 t(:str, "foo", Type.str),
+                 t(:str, "bar", Type.str)),
+               Type.str_list)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lasgn_masgn
+    @type_checker.env.extend
+    input  = t(:lasgn, :var)
+    output = t(:lasgn, :var, nil, Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lit_float
+    input  = t(:lit, 1.0)
+    output = t(:lit, 1.0, Type.float)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lit_long
+    input  = t(:lit, 1)
+    output = t(:lit, 1, Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lit_sym
+    input  = t(:lit, :sym)
+    output = t(:lit, :sym, Type.symbol)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_lvar
+    add_fake_var :arg, Type.long
+    input  = t(:lvar, :arg)
+    output = t(:lvar, :arg, Type.long)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_masgn_equal_args
+    input  = s(:masgn,
+               s(:array,
+                 s(:lasgn, :a),
+                 s(:lasgn, :b)),
+               s(:array, s(:lit, 1), s(:lit, 2)))
+    output = t(:masgn,
+               t(:array,
+                 t(:lasgn, :a, nil, Type.long),
+                 t(:lasgn, :b, nil, Type.long)),
+               t(:array,
+                 t(:lit, 1, Type.long),
+                 t(:lit, 2, Type.long),
+                 Type.long_list))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_masgn_less_args
+    input  = s(:masgn,
+               s(:array,
+                 s(:lasgn, :a),
+                 s(:lasgn, :b)),
+               s(:to_ary, s(:lit, 1)))
+    output = t(:masgn,
+               t(:array,
+                 t(:lasgn, :a, nil, Type.long),
+                 t(:lasgn, :b, nil, Type.value)),
+               t(:to_ary,
+                 t(:lit, 1, Type.long),
+                 Type.long_list))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_masgn_more_args
+    input  = s(:masgn,
+               s(:array,
+                 s(:lasgn, :a),
+                 s(:lasgn, :b)),
+               s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3)))
+    output = t(:masgn,
+               t(:array,
+                 t(:lasgn, :a, nil, Type.long),
+                 t(:lasgn, :b, nil, Type.long_list)),
+               t(:array,
+                 t(:lit, 1, Type.long),
+                 t(:lit, 2, Type.long),
+                 t(:lit, 3, Type.long),
+                 Type.long_list))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_nil
+    input  = t(:nil)
+    output = t(:nil, Type.value)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_not
+    input  = t(:not, t(:true))
+    output = t(:not, t(:true, Type.bool), Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_or
+    input  = t(:or, t(:true), t(:false))
+    output = t(:or, t(:true, Type.bool), t(:false, Type.bool), Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+#   def test_process_rescue
+#     assert_raises RuntimeError do
+#       @type_checker.process s(:rescue, s(:true), s(:true))
+#     end
+#   end
+
+  def test_process_return
+    input  = t(:return, t(:nil))
+    output = t(:return, t(:nil, Type.value), Type.void)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_scope
+    input  = t(:scope,
+               t(:block,
+                 t(:return, t(:nil))))
+    output = t(:scope,
+               t(:block,
+                 t(:return,
+                   t(:nil, Type.value),
+                   Type.void),
+                 Type.unknown), # FIX ? do we care about block?
+               Type.void)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_scope_empty
+    input =   t(:scope)
+    output = t(:scope, Type.void)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_str
+    input  = t(:str, "foo")
+    output = t(:str, "foo", Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_to_ary
+    input  = s(:to_ary, s(:lit, 1), s(:lit, 2))
+    output = t(:to_ary,
+               t(:lit, 1, Type.long),
+               t(:lit, 2, Type.long),
+               Type.long_list)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_true
+    input =  t(:true)
+    output = t(:true, Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_unless
+    input  = t(:if,
+               t(:call,
+                 t(:lit, 1),
+                 :==,
+                 t(:arglist, t(:lit, 2))),
+               nil,
+               t(:str, "equal"))
+    output = t(:if,
+               t(:call,
+                 t(:lit, 1, Type.long),
+                 :==,
+                 t(:arglist,
+                   t(:lit, 2, Type.long)),
+                 Type.bool),
+               nil,
+               t(:str, "equal", Type.str),
+               Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_while
+    input    = t(:while, t(:true), t(:call, t(:lit, 1), :to_s, nil), true)
+    expected = t(:while,
+                 t(:true, Type.bool),
+                 t(:call, t(:lit, 1, Type.long), :to_s, nil,
+                   Type.str), true)
+
+    assert_equal expected, @type_checker.process(input)
+  end
+
+  def add_fake_function(name, reciever_type, return_type, *arg_types)
+    @type_checker.functions.add_function(name,
+                                         Type.function(reciever_type, arg_types, return_type))
+  end
+
+  def add_fake_var(name, type)
+    @type_checker.env.extend
+    @type_checker.env.add name, type
+  end
+
+  def add_fake_gvar(name, type)
+    @type_checker.genv.add name, type
+  end
+end
+