ruby2c 1.0.0.9 → 1.1.1

data/test/test_type_checker.rb

@@ -19,18 +19,18 @@ 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
+    @type_checker.env.add :argl, CType.long
+    @type_checker.env.add :args, CType.str
+    @type_checker.env.add :arrayl, CType.long_list
+    @type_checker.env.add :arrayl2, CType.long_list
+    @type_checker.env.add :arrays, CType.str_list
+    @type_checker.genv.add :SyntaxError, CType.fucked
+    @type_checker.genv.add :Exception, CType.fucked
 
     # HACK
-    @type_checker.genv.add :$stdin, Type.file
-    @type_checker.genv.add :$stdout, Type.file
-    @type_checker.genv.add :$stderr, Type.file
+    @type_checker.genv.add :$stdin, CType.file
+    @type_checker.genv.add :$stdout, CType.file
+    @type_checker.genv.add :$stderr, CType.file
   end
 
   def test_bootstrap
@@ -38,46 +38,46 @@ class TestTypeChecker < R2CTestCase
     # 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 CType.file, @type_checker.genv.lookup(:$stdin)
+#     assert_equal CType.file, @type_checker.genv.lookup(:$stdout)
+#     assert_equal CType.file, @type_checker.genv.lookup(:$stderr)
 
-    assert_equal(Type.function(Type.long, [Type.long], Type.bool),
+    assert_equal(CType.function(CType.long, [CType.long], CType.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
+    add_fake_function :specific, CType.unknown, CType.unknown, CType.unknown
 
     # now in specific, unify with a long
-    s = @type_checker.process(s(:defn, :specific,
+    _ = @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,
+    assert_equal(CType.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)
+    @type_checker.env.add :blah, CType.long
+    assert_equal CType.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),
+    assert_equal(CType.function(CType.long, [CType.long], CType.bool),
                  @type_checker.functions[:>])
   end
 
 # HACK
 #   def test_genv
-#     assert_equal Type.file, @type_checker.genv.lookup(:$stderr)
+#     assert_equal CType.file, @type_checker.genv.lookup(:$stderr)
 #   end
 
   def test_process_args
@@ -85,8 +85,8 @@ class TestTypeChecker < R2CTestCase
 
     input =  t(:args, :foo, :bar)
     output = t(:args,
-               t(:foo, Type.unknown),
-               t(:bar, Type.unknown))
+               t(:foo, CType.unknown),
+               t(:bar, CType.unknown))
 
     assert_equal output, @type_checker.process(input)
   end
@@ -100,27 +100,27 @@ class TestTypeChecker < R2CTestCase
   end
 
   def test_process_array_multiple
-    add_fake_var :arg1, Type.long
-    add_fake_var :arg2, Type.str
+    add_fake_var :arg1, CType.long
+    add_fake_var :arg2, CType.str
 
     input =  t(:array, t(:lvar, :arg1), t(:lvar, :arg2))
     output = t(:array,
-               t(:lvar, :arg1, Type.long),
-               t(:lvar, :arg2, Type.str))
+               t(:lvar, :arg1, CType.long),
+               t(:lvar, :arg2, CType.str))
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_array_single
-    add_fake_var :arg1, Type.long
+    add_fake_var :arg1, CType.long
 
     input  = t(:array, t(:lvar, :arg1))
-    output = t(:array, t(:lvar, :arg1, Type.long))
+    output = t(:array, t(:lvar, :arg1, CType.long))
 
     result = @type_checker.process(input)
 
-    assert_equal Type.homo, result.sexp_type
-    assert_equal [ Type.long ], result.sexp_types
+    assert_equal CType.homo, result.c_type
+    assert_equal [ CType.long ], result.c_types
     assert_equal output, result
   end
 
@@ -129,9 +129,9 @@ class TestTypeChecker < R2CTestCase
     # FIX: should this really be void for return?
     output = t(:block,
                t(:return,
-                 t(:nil, Type.value),
-                 Type.void),
-               Type.unknown)
+                 t(:nil, CType.value),
+                 CType.void),
+               CType.unknown)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -141,51 +141,51 @@ class TestTypeChecker < R2CTestCase
                t(:str, :foo),
                t(:return, t(:nil)))
     output = t(:block,
-               t(:str, :foo, Type.str),
+               t(:str, :foo, CType.str),
                t(:return,
-                 t(:nil, Type.value),
-                 Type.void),
-               Type.unknown)
+                 t(:nil, CType.value),
+                 CType.void),
+               CType.unknown)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_call_case_equal_long
-    add_fake_var :number, Type.unknown
+    add_fake_var :number, CType.unknown
 
     input  = t(:call,
                t(:lit, 1),
                :===,
                t(:arglist, t(:lvar, :number)))
     output = t(:call,
-               t(:lit, 1, Type.long),
+               t(:lit, 1, CType.long),
                :case_equal_long,
                t(:arglist,
-                 t(:lvar, :number, Type.long)),
-               Type.bool)
+                 t(:lvar, :number, CType.long)),
+               CType.bool)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_call_case_equal_string
-    add_fake_var :string, Type.unknown
+    add_fake_var :string, CType.unknown
 
     input  = t(:call,
                t(:str, 'foo'),
                :===,
                t(:arglist, t(:lvar, :string)))
     output = t(:call,
-               t(:str, 'foo', Type.str),
+               t(:str, 'foo', CType.str),
                :case_equal_str,
                t(:arglist,
-                 t(:lvar, :string, Type.str)),
-               Type.bool)
+                 t(:lvar, :string, CType.str)),
+               CType.bool)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_call_defined
-    add_fake_function :name, Type.void, Type.long, Type.str
+    add_fake_function :name, CType.void, CType.long, CType.str
     input  = t(:call,
                nil,
                :name,
@@ -193,68 +193,68 @@ class TestTypeChecker < R2CTestCase
     output = t(:call,
                nil,
                :name,
-               t(:arglist, t(:str, "foo", Type.str)),
-               Type.long)
+               t(:arglist, t(:str, "foo", CType.str)),
+               CType.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
+    add_fake_function :name3, CType.long, CType.long, CType.str
     input  = t(:call,
                t(:lit, 1),
                :name3,
                t(:arglist, t(:str, "foo")))
     output = t(:call,
-               t(:lit, 1, Type.long),
+               t(:lit, 1, CType.long),
                :name3,
-               t(:arglist, t(:str, "foo", Type.str)),
-               Type.long)
+               t(:arglist, t(:str, "foo", CType.str)),
+               CType.long)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_call_undefined
     input  = t(:call, nil, :name)
-    output = t(:call, nil, :name, t(:arglist), Type.unknown)
+    output = t(:call, nil, :name, t(:arglist), CType.unknown)
 
     assert_equal output, @type_checker.process(input)
     # FIX returns unknown in s()
-    assert_equal(Type.function(Type.unknown, [], Type.unknown),
+    assert_equal(CType.function(CType.unknown, [], CType.unknown),
                  @type_checker.functions[:name])
   end
 
   def test_process_call_unify_1
-    add_fake_var :number, Type.long
+    add_fake_var :number, CType.long
     input  = t(:call,
                t(:lit, 1),
                :==,
                t(:arglist,
                  t(:lvar, :number)))
     output = t(:call,
-               t(:lit, 1, Type.long),
+               t(:lit, 1, CType.long),
                :==,
                t(:arglist,
-                 t(:lvar, :number, Type.long)),
-               Type.bool)
+                 t(:lvar, :number, CType.long)),
+               CType.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
+    add_fake_var :number1, CType.unknown
+    add_fake_var :number2, CType.unknown
 
     input  = t(:call,
                t(:lit, 1),
                :==,
                t(:arglist, t(:lvar, :number1)))
     output = t(:call,
-               t(:lit, 1, Type.long),
+               t(:lit, 1, CType.long),
                :==,
                t(:arglist,
-                 t(:lvar, :number1, Type.long)),
-               Type.bool)
+                 t(:lvar, :number1, CType.long)),
+               CType.bool)
 
     assert_equal output, @type_checker.process(input)
 
@@ -263,18 +263,18 @@ class TestTypeChecker < R2CTestCase
                :==,
                t(:arglist, t(:lit, 1)))
     output = t(:call,
-               t(:lvar, :number2, Type.long),
+               t(:lvar, :number2, CType.long),
                :==,
                t(:arglist,
-                 t(:lit, 1, Type.long)),
-               Type.bool)
+                 t(:lit, 1, CType.long)),
+               CType.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
+    a_type = CType.unknown
+    add_fake_var :a, a_type # TODO: CType.unknown
 
     # def unify_3_outer(a)
     #
@@ -284,7 +284,7 @@ class TestTypeChecker < R2CTestCase
     # outer(., ., [+])
 
     # assume the environment got everything set up correctly
-    add_fake_function(:unify_3_outer, Type.void, Type.void, a_type)
+    add_fake_function(:unify_3_outer, CType.void, CType.void, a_type)
 
     assert_equal(a_type,
                  @type_checker.functions[:unify_3_outer].list_type.formal_types[0])
@@ -325,7 +325,7 @@ class TestTypeChecker < R2CTestCase
       @type_checker.process t(:lasgn, :a, t(:lit, 1))
     end
 
-    assert_equal a_type, Type.long
+    assert_equal a_type, CType.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])
@@ -341,16 +341,16 @@ class TestTypeChecker < R2CTestCase
                     s(:lasgn, :x, s(:const, :VALUE))))))
     output = t(:class, :X, :Object,
                t(:defn, :meth,
-                 t(:args, t(:x, Type.long)),
+                 t(:args, t(:x, CType.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)
+                       t(:const, :VALUE, CType.long),
+                       CType.long),
+                     CType.unknown),
+                   CType.void),
+                 CType.function(CType.unknown, [CType.long], CType.void)),
+               CType.zclass)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -363,14 +363,14 @@ class TestTypeChecker < R2CTestCase
 
   def test_process_cvar
     input  = s(:cvar, :name)
-    output = t(:cvar, :name, Type.unknown)
+    output = t(:cvar, :name, CType.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)
+    output = t(:cvasgn, :name, t(:lit, 4, CType.long), CType.unknown)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -378,15 +378,15 @@ class TestTypeChecker < R2CTestCase
   def test_process_dasgn_curr
     @type_checker.env.extend
     input  = t(:dasgn_curr, :x)
-    output = t(:dasgn_curr, :x, Type.unknown)
+    output = t(:dasgn_curr, :x, CType.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)
+    # assert_equal CType.long, @type_checker.env.lookup(:x)
   end
 
   def test_process_defn
-    function_type = Type.function s(), Type.void
+    function_type = CType.function s(), CType.void
     input  = t(:defn,
                :empty,
                t(:args),
@@ -394,66 +394,66 @@ class TestTypeChecker < R2CTestCase
     output = t(:defn,
                :empty,
                t(:args),
-               t(:scope, Type.void),
+               t(:scope, CType.void),
                function_type)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_dstr
-    add_fake_var :var, Type.str
+    add_fake_var :var, CType.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)
+               t(:lvar, :var, CType.str),
+               t(:str, ". So there.", CType.str),
+               CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_dvar
-    add_fake_var :dvar, Type.long
+    add_fake_var :dvar, CType.long
     input  = t(:dvar, :dvar)
-    output = t(:dvar, :dvar, Type.long)
+    output = t(:dvar, :dvar, CType.long)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_false
     input =   t(:false)
-    output = t(:false, Type.bool)
+    output = t(:false, CType.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)
+    expected = t(:gasgn, :$blah, t(:lit, 42, CType.long), CType.long)
 
     assert_equal expected, @type_checker.process(input)
   end
 
   def test_process_gvar_defined
-    add_fake_gvar :$arg, Type.long
+    add_fake_gvar :$arg, CType.long
     input  = t(:gvar, :$arg)
-    output = t(:gvar, :$arg, Type.long)
+    output = t(:gvar, :$arg, CType.long)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_gvar_undefined
     input  = t(:gvar, :$arg)
-    output = t(:gvar, :$arg, Type.unknown)
+    output = t(:gvar, :$arg, CType.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)
+    expected = t(:iasgn, :@blah, t(:lit, 42, CType.long), CType.long)
 
     assert_equal expected, @type_checker.process(input)
   end
@@ -468,14 +468,14 @@ class TestTypeChecker < R2CTestCase
                nil)
     output = t(:if,
                t(:call,
-                 t(:lit, 1, Type.long),
+                 t(:lit, 1, CType.long),
                  :==,
                  t(:arglist,
-                   t(:lit, 2, Type.long)),
-                 Type.bool),
-               t(:str, "not equal", Type.str),
+                   t(:lit, 2, CType.long)),
+                 CType.bool),
+               t(:str, "not equal", CType.str),
                nil,
-               Type.str)
+               CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -490,20 +490,20 @@ class TestTypeChecker < R2CTestCase
                t(:str, "equal"))
     output = t(:if,
                t(:call,
-                 t(:lit, 1, Type.long),
+                 t(:lit, 1, CType.long),
                  :==,
-                 t(:arglist, t(:lit, 2, Type.long)),
-                 Type.bool),
-               t(:str, "not equal", Type.str),
-               t(:str, "equal", Type.str),
-               Type.str)
+                 t(:arglist, t(:lit, 2, CType.long)),
+                 CType.bool),
+               t(:str, "not equal", CType.str),
+               t(:str, "equal", CType.str),
+               CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_iter
     @type_checker.env.extend
-    var_type = Type.long_list
+    var_type = CType.long_list
     add_fake_var :array, var_type
     input  = t(:iter,
                t(:call,
@@ -524,27 +524,27 @@ class TestTypeChecker < R2CTestCase
                  t(:lvar, :array, var_type),
                  :each,
                  t(:arglist),
-                 Type.unknown),
-               t(:args, t(:lasgn, :x, nil, Type.long)),
+                 CType.unknown),
+               t(:args, t(:lasgn, :x, nil, CType.long)),
                t(:call,
                  nil,
                  :puts,
                  t(:arglist,
                    t(:call,
-                     t(:dvar, :x, Type.long),
+                     t(:dvar, :x, CType.long),
                      :to_s,
                      t(:arglist),
-                     Type.str)),
-                 Type.void),
-               Type.void)
+                     CType.str)),
+                 CType.void),
+               CType.void)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_ivar
-    @type_checker.env.add :@blah, Type.long
+    @type_checker.env.add :@blah, CType.long
     input = s(:ivar, :@blah)
-    expected = t(:ivar, :@blah, Type.long)
+    expected = t(:ivar, :@blah, CType.long)
 
     assert_equal expected, @type_checker.process(input)
   end
@@ -563,8 +563,8 @@ class TestTypeChecker < R2CTestCase
     # makes debugging very difficult
     input  = t(:lasgn, :var, t(:str, "foo"))
     output = t(:lasgn, :var,
-               t(:str, "foo", Type.str),
-               Type.str)
+               t(:str, "foo", CType.str),
+               CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -578,9 +578,9 @@ class TestTypeChecker < R2CTestCase
                  t(:str, "bar")))
     output = t(:lasgn, :var,
                t(:array,
-                 t(:str, "foo", Type.str),
-                 t(:str, "bar", Type.str)),
-               Type.str_list)
+                 t(:str, "foo", CType.str),
+                 t(:str, "bar", CType.str)),
+               CType.str_list)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -588,36 +588,36 @@ class TestTypeChecker < R2CTestCase
   def test_process_lasgn_masgn
     @type_checker.env.extend
     input  = t(:lasgn, :var)
-    output = t(:lasgn, :var, nil, Type.unknown)
+    output = t(:lasgn, :var, nil, CType.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)
+    output = t(:lit, 1.0, CType.float)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_lit_long
     input  = t(:lit, 1)
-    output = t(:lit, 1, Type.long)
+    output = t(:lit, 1, CType.long)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_lit_sym
     input  = t(:lit, :sym)
-    output = t(:lit, :sym, Type.symbol)
+    output = t(:lit, :sym, CType.symbol)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_lvar
-    add_fake_var :arg, Type.long
+    add_fake_var :arg, CType.long
     input  = t(:lvar, :arg)
-    output = t(:lvar, :arg, Type.long)
+    output = t(:lvar, :arg, CType.long)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -630,12 +630,12 @@ class TestTypeChecker < R2CTestCase
                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(:lasgn, :a, nil, CType.long),
+                 t(:lasgn, :b, nil, CType.long)),
                t(:array,
-                 t(:lit, 1, Type.long),
-                 t(:lit, 2, Type.long),
-                 Type.long_list))
+                 t(:lit, 1, CType.long),
+                 t(:lit, 2, CType.long),
+                 CType.long_list))
 
     assert_equal output, @type_checker.process(input)
   end
@@ -648,11 +648,11 @@ class TestTypeChecker < R2CTestCase
                s(:to_ary, s(:lit, 1)))
     output = t(:masgn,
                t(:array,
-                 t(:lasgn, :a, nil, Type.long),
-                 t(:lasgn, :b, nil, Type.value)),
+                 t(:lasgn, :a, nil, CType.long),
+                 t(:lasgn, :b, nil, CType.value)),
                t(:to_ary,
-                 t(:lit, 1, Type.long),
-                 Type.long_list))
+                 t(:lit, 1, CType.long),
+                 CType.long_list))
 
     assert_equal output, @type_checker.process(input)
   end
@@ -665,34 +665,34 @@ class TestTypeChecker < R2CTestCase
                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(:lasgn, :a, nil, CType.long),
+                 t(:lasgn, :b, nil, CType.long_list)),
                t(:array,
-                 t(:lit, 1, Type.long),
-                 t(:lit, 2, Type.long),
-                 t(:lit, 3, Type.long),
-                 Type.long_list))
+                 t(:lit, 1, CType.long),
+                 t(:lit, 2, CType.long),
+                 t(:lit, 3, CType.long),
+                 CType.long_list))
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_nil
     input  = t(:nil)
-    output = t(:nil, Type.value)
+    output = t(:nil, CType.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)
+    output = t(:not, t(:true, CType.bool), CType.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)
+    output = t(:or, t(:true, CType.bool), t(:false, CType.bool), CType.bool)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -705,7 +705,7 @@ class TestTypeChecker < R2CTestCase
 
   def test_process_return
     input  = t(:return, t(:nil))
-    output = t(:return, t(:nil, Type.value), Type.void)
+    output = t(:return, t(:nil, CType.value), CType.void)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -717,24 +717,24 @@ class TestTypeChecker < R2CTestCase
     output = t(:scope,
                t(:block,
                  t(:return,
-                   t(:nil, Type.value),
-                   Type.void),
-                 Type.unknown), # FIX ? do we care about block?
-               Type.void)
+                   t(:nil, CType.value),
+                   CType.void),
+                 CType.unknown), # FIX ? do we care about block?
+               CType.void)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_scope_empty
     input =   t(:scope)
-    output = t(:scope, Type.void)
+    output = t(:scope, CType.void)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_str
     input  = t(:str, "foo")
-    output = t(:str, "foo", Type.str)
+    output = t(:str, "foo", CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -742,16 +742,16 @@ class TestTypeChecker < R2CTestCase
   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)
+               t(:lit, 1, CType.long),
+               t(:lit, 2, CType.long),
+               CType.long_list)
 
     assert_equal output, @type_checker.process(input)
   end
 
   def test_process_true
     input =  t(:true)
-    output = t(:true, Type.bool)
+    output = t(:true, CType.bool)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -766,14 +766,14 @@ class TestTypeChecker < R2CTestCase
                t(:str, "equal"))
     output = t(:if,
                t(:call,
-                 t(:lit, 1, Type.long),
+                 t(:lit, 1, CType.long),
                  :==,
                  t(:arglist,
-                   t(:lit, 2, Type.long)),
-                 Type.bool),
+                   t(:lit, 2, CType.long)),
+                 CType.bool),
                nil,
-               t(:str, "equal", Type.str),
-               Type.str)
+               t(:str, "equal", CType.str),
+               CType.str)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -781,16 +781,16 @@ class TestTypeChecker < R2CTestCase
   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, t(:arglist),
-                   Type.str), true)
+                 t(:true, CType.bool),
+                 t(:call, t(:lit, 1, CType.long), :to_s, t(:arglist),
+                   CType.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))
+                                         CType.function(reciever_type, arg_types, return_type))
   end
 
   def add_fake_var(name, type)