rdl 2.0.1 → 2.1.0

data/test/test_rdl.rb

@@ -3,6 +3,7 @@ $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
 
 class TestRDL < Minitest::Test
+  extend RDL::Annotate
 
   # Test wrapping with no types or contracts
   def test_wrap
@@ -61,7 +62,7 @@ class TestRDL < Minitest::Test
   def test_pre_contract
     pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
     def m5(x) return x; end
-    pre TestRDL, :m5, pos
+    RDL.pre TestRDL, :m5, pos
     assert_equal 3, m5(3)
     assert_raises(RDL::Contract::ContractError) { m5(-1) }
   end
@@ -69,7 +70,7 @@ class TestRDL < Minitest::Test
   def test_post_contract
     neg = RDL::Contract::FlatContract.new("Negative") { |x| x < 0 }
     def m6(x) return 3; end
-    post TestRDL, :m6, neg
+    RDL.post TestRDL, :m6, neg
     assert_raises(RDL::Contract::ContractError) { m6(42) }
   end
 
@@ -77,8 +78,8 @@ class TestRDL < Minitest::Test
     pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
     ppos = RDL::Contract::FlatContract.new("Positive") { |r, x| r > 0 }
     def m7(x) return x; end
-    pre TestRDL, :m7, pos
-    post TestRDL, :m7, ppos
+    RDL.pre TestRDL, :m7, pos
+    RDL.post TestRDL, :m7, ppos
     assert_equal 3, m7(3)
   end
 
@@ -87,15 +88,15 @@ class TestRDL < Minitest::Test
     five = RDL::Contract::FlatContract.new("Five") { |x| x == 5 }
     gt = RDL::Contract::FlatContract.new("Greater Than 3") { |x| x > 3 }
     def m8(x) return x; end
-    pre TestRDL, :m8, pos
-    pre TestRDL, :m8, gt
+    RDL.pre TestRDL, :m8, pos
+    RDL.pre TestRDL, :m8, gt
     assert_equal 5, m8(5)
     assert_equal 4, m8(4)
     assert_raises(RDL::Contract::ContractError) { m8 3 }
     def m9(x) return x; end
-    pre TestRDL, :m9, pos
-    pre TestRDL, :m9, gt
-    pre TestRDL, :m9, five
+    RDL.pre TestRDL, :m9, pos
+    RDL.pre TestRDL, :m9, gt
+    RDL.pre TestRDL, :m9, five
     assert_equal 5, m9(5)
     assert_raises(RDL::Contract::ContractError) { m9 4 }
     assert_raises(RDL::Contract::ContractError) { m9 3 }
@@ -104,15 +105,15 @@ class TestRDL < Minitest::Test
     pfive = RDL::Contract::FlatContract.new("Five") { |r, x| r == 5 }
     pgt = RDL::Contract::FlatContract.new("Greater Than 3") { |r, x| r > 3 }
     def m10(x) return x; end
-    post TestRDL, :m10, ppos
-    post TestRDL, :m10, pgt
+    RDL.post TestRDL, :m10, ppos
+    RDL.post TestRDL, :m10, pgt
     assert_equal 5, m10(5)
     assert_equal 4, m10(4)
     assert_raises(RDL::Contract::ContractError) { m10 3 }
     def m11(x) return x; end
-    post TestRDL, :m11, ppos
-    post TestRDL, :m11, pgt
-    post TestRDL, :m11, pfive
+    RDL.post TestRDL, :m11, ppos
+    RDL.post TestRDL, :m11, pgt
+    RDL.post TestRDL, :m11, pfive
     assert_equal 5, m11(5)
     assert_raises(RDL::Contract::ContractError) { m11 4 }
     assert_raises(RDL::Contract::ContractError) { m11 3 }
@@ -120,13 +121,13 @@ class TestRDL < Minitest::Test
 
   def test_deferred_wrap
     pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
-    pre TestRDL, :m12, pos
+    RDL.pre TestRDL, :m12, pos
     def m12(x) return x; end
     assert_equal 3, m12(3)
     assert_raises(RDL::Contract::ContractError) { m12(-1) }
 
     ppos = RDL::Contract::FlatContract.new("Positive") { |r, x| r > 0 }
-    post TestRDL, :m13, ppos
+    RDL.post TestRDL, :m13, ppos
     def m13(x) return x; end
     assert_equal 3, m13(3)
     assert_raises(RDL::Contract::ContractError) { m13(-1) }
@@ -218,42 +219,43 @@ RUBY
   end
 
   def test_type_params
-    self.class.class_eval "class TP1; type_params [:t], :all? end"
+    self.class.class_eval "class TP1; extend RDL::Annotate; type_params [:t], :all? end"
     assert_equal [[:t], [:~], :all?], RDL::Wrap.get_type_params(TestRDL::TP1)
-    self.class.class_eval "class TP2; type_params([:t], nil) { |t| true } end"
+    self.class.class_eval "class TP2; extend RDL::Annotate; type_params([:t], nil) { |t| true } end"
     tp2 = RDL::Wrap.get_type_params(TestRDL::TP2)
     assert_equal [:t], tp2[0]
     assert_equal [:~], tp2[1]
-    assert_raises(RuntimeError) { self.class.class_eval "class TP1; type_params [:t], :all? end" }
-    self.class.class_eval "class TP3; type_params [:t, :u], :all? end"
+    assert_raises(RuntimeError) { self.class.class_eval "class TP1; extend RDL::Annotate; type_params [:t], :all? end" }
+    self.class.class_eval "class TP3; extend RDL::Annotate; type_params [:t, :u], :all? end"
     assert_equal [[:t, :u], [:~, :~], :all?], RDL::Wrap.get_type_params(TestRDL::TP3)
 
-    self.class.class_eval "class TP4; type_params [:t, :u, :v], :all?, variance: [:+, :-, :~] end"
+    self.class.class_eval "class TP4; extend RDL::Annotate; type_params [:t, :u, :v], :all?, variance: [:+, :-, :~] end"
     assert_equal [[:t, :u, :v], [:+, :-, :~], :all?], RDL::Wrap.get_type_params(TestRDL::TP4)
-    assert_raises(RuntimeError) { self.class.class_eval "class TP5; type_params([], :all?) { true } end" }
-    assert_raises(RuntimeError) { self.class.class_eval "class TP6; type_params [:t, :u], :all?, variance: [:+] end" }
-    assert_raises(RuntimeError) { self.class.class_eval "class TP7; type_params [:t, :u], :all?, variance: [:a, :b] end" }
-    assert_raises(RuntimeError) { self.class.class_eval "class TP8; type_params([:t], :all?) { |t| true } end" }
-    assert_raises(RuntimeError) { self.class.class_eval "class TP8; type_params [:t], 42 end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP5; extend RDL::Annotate; type_params([], :all?) { true } end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP6; extend RDL::Annotate; type_params [:t, :u], :all?, variance: [:+] end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP7; extend RDL::Annotate; type_params [:t, :u], :all?, variance: [:a, :b] end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP8; extend RDL::Annotate; type_params([:t], :all?) { |t| true } end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP8; extend RDL::Annotate; type_params [:t], 42 end" }
   end
 
   def test_wrap_new
     self.class.class_eval "class B; def initialize(x); @x = x end; def get(); return @x end end"
-    pre("TestRDL::B", "self.new") { |x| x > 0 }
+    RDL.pre("TestRDL::B", "self.new") { |x| x > 0 }
     assert_equal 3, TestRDL::B.new(3).get
     assert_raises(RDL::Contract::ContractError) { TestRDL::B.new(-3) }
 
-    self.class.class_eval "class C; pre { |x| x > 0 }; def initialize(x); @x = x end; def get(); return @x end end"
+    self.class.class_eval "class C; extend RDL::Annotate; pre { |x| x > 0 }; def initialize(x); @x = x end; def get(); return @x end end"
     assert_equal 3, TestRDL::C.new(3).get
     assert_raises(RDL::Contract::ContractError) { TestRDL::C.new(-3) }
 
     self.class.class_eval "class D; def get(); return @x end end"
-    pre("TestRDL::D", "self.new") { |x| x > 0 }
+    RDL.pre("TestRDL::D", "self.new") { |x| x > 0 }
     self.class.class_eval "class D; def initialize(x); @x = x end end"
     assert_equal 3, TestRDL::D.new(3).get
     assert_raises(RDL::Contract::ContractError) { TestRDL::D.new(-3) }
 
     skip "Can't defer contracts on new yet"
+    RDL.
     pre("TestRDL::E", "self.new") { |x| x > 0 }
     self.class.class_eval "class E; def initialize(x); @x = x end end"
     assert (TestRDL::E.new(3))
@@ -263,13 +265,13 @@ RUBY
   def test_class_method
     pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
     self.class.class_eval { def self.cm1(x) return x; end }
-    pre TestRDL, "self.cm1", pos
+    RDL.pre TestRDL, "self.cm1", pos
     assert_equal 3, TestRDL.cm1(3)
     assert_raises(RDL::Contract::ContractError) { TestRDL.cm1(-1) }
 
-    assert_raises(RuntimeError) { pre TestRDL, "TestRDL.cm1", pos }
+    assert_raises(RuntimeError) { RDL.pre TestRDL, "TestRDL.cm1", pos }
 
-    pre TestRDL, "self.cm2", pos
+    RDL.pre TestRDL, "self.cm2", pos
     self.class.class_eval { def self.cm2(x) return x; end }
     assert_equal 3, TestRDL.cm2(3)
     assert_raises(RDL::Contract::ContractError) { TestRDL.cm2(-1) }
@@ -283,11 +285,11 @@ RUBY
   end
 
   def test_cast
-    obj1 = 3.type_cast($__rdl_nil_type, force: true)
-    assert ($__rdl_nil_type.member? obj1)
-    obj2 = 3.type_cast('nil', force: true)
-    assert ($__rdl_nil_type.member? obj2)
-    assert_raises(RuntimeError) { 3.type_cast($__rdl_nil_type) }
+    obj1 = RDL.type_cast(3, RDL::Globals.types[:nil], force: true)
+    assert (RDL::Globals.types[:nil].member? obj1)
+    obj2 = RDL.type_cast(3, 'nil', force: true)
+    assert (RDL::Globals.types[:nil].member? obj2)
+    assert_raises(RuntimeError) { RDL.type_cast(3, RDL::Globals.types[:nil]) }
   end
 
   def test_pre_post_self
@@ -300,34 +302,34 @@ RUBY
   end
 
   def test_nowrap
-    pre(TestRDL, :nwrap1) { true }
+    RDL.pre(TestRDL, :nwrap1) { true }
     def nwrap1(x) return x; end
     assert(RDL::Wrap.wrapped?(TestRDL, :nwrap1))
-    pre(TestRDL, :nwrap2, wrap: false) { true }
+    RDL.pre(TestRDL, :nwrap2, wrap: false) { true }
     def nwrap2(x) return x; end
     assert(not(RDL::Wrap.wrapped?(TestRDL, :nwrap2)))
 
-    post(TestRDL, :nwrap3) { true }
+    RDL.post(TestRDL, :nwrap3) { true }
     def nwrap3(x) return x; end
     assert(RDL::Wrap.wrapped?(TestRDL, :nwrap3))
-    post(TestRDL, :nwrap4, wrap: false) { true }
+    RDL.post(TestRDL, :nwrap4, wrap: false) { true }
     def nwrap4(x) return x; end
     assert(not(RDL::Wrap.wrapped?(TestRDL, :nwrap4)))
 
-    type TestRDL, :nwrap5, "(Fixnum) -> Fixnum"
+    RDL.type TestRDL, :nwrap5, "(Integer) -> Integer"
     def nwrap5(x) return x; end
     assert(RDL::Wrap.wrapped?(TestRDL, :nwrap5))
-    type TestRDL, :nwrap6, "(Fixnum) -> Fixnum", wrap: false
+    RDL.type TestRDL, :nwrap6, "(Integer) -> Integer", wrap: false
     def nwrap6(x) return x; end
     assert(not(RDL::Wrap.wrapped?(TestRDL, :nwrap6)))
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
+      type "(Integer) -> Integer"
       def nwrap7(x) return x; end
     }
     assert(RDL::Wrap.wrapped?(TestRDL, :nwrap7))
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum", wrap: false
+      type "(Integer) -> Integer", wrap: false
       def nwrap8(x) return x; end
     }
     assert(not(RDL::Wrap.wrapped?(TestRDL, :nwrap8)))
@@ -335,18 +337,18 @@ RUBY
 
   def test_var_type
     self.class.class_eval {
-      var_type :@foo, "Fixnum"
+      var_type :@foo, "Integer"
       var_type :@@foo, "String"
       var_type :$foo, "Symbol"
     }
-    assert_equal $__rdl_fixnum_type, $__rdl_info.get(TestRDL, :@foo, :type)
-    assert_equal $__rdl_string_type, $__rdl_info.get(TestRDL, :@@foo, :type)
-    assert_equal $__rdl_symbol_type, $__rdl_info.get(RDL::Util::GLOBAL_NAME, :$foo, :type)
+    assert_equal RDL::Globals.types[:integer], RDL::Globals.info.get(TestRDL, :@foo, :type)
+    assert_equal RDL::Globals.types[:string], RDL::Globals.info.get(TestRDL, :@@foo, :type)
+    assert_equal RDL::Globals.types[:symbol], RDL::Globals.info.get(RDL::Util::GLOBAL_NAME, :$foo, :type)
     assert_raises(RuntimeError) {
       self.class.class_eval { var_type :@foo, "String" }
     }
     assert_raises(RuntimeError) {
-      self.class.class_eval { var_type :@@foo, "Fixnum" }
+      self.class.class_eval { var_type :@@foo, "Integer" }
     }
     assert_raises(RuntimeError) {
       self.class.class_eval { var_type :Foo, "String" }
@@ -358,7 +360,7 @@ RUBY
 
   def test_inconsistent
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
+      type "(Integer) -> Integer"
       pre { |x| true }
       def inconsistent1(y) return y; end
     }
@@ -370,8 +372,41 @@ RUBY
       def remove1() return 42; end
     }
     assert_raises(RDL::Type::TypeError) { remove1 }
-    rdl_remove_type(self.class, :remove1)
+    RDL.remove_type(self.class, :remove1)
     assert_equal 42, remove1 # shouldn't raise type error with contract removed
   end
 
+  def test_version
+    RDL.pre("TestRDL::TestVersion", "m1", version: Gem.ruby_version.to_s) { true }
+    assert (RDL::Globals.info.has? "TestRDL::TestVersion", "m1", :pre)
+    RDL.pre("TestRDL::TestVersion", "m2", version: Gem.ruby_version.bump.to_s) { true }
+    assert !(RDL::Globals.info.has? "TestRDL::TestVersion", "m2", :pre)
+    RDL.post("TestRDL::TestVersion", "m3", version: Gem.ruby_version.to_s) { true }
+    assert (RDL::Globals.info.has? "TestRDL::TestVersion", "m3", :post)
+    RDL.
+    pre("TestRDL::TestVersion", "m4", version: Gem.ruby_version.bump.to_s) { true }
+    assert !(RDL::Globals.info.has? "TestRDL::TestVersion", "m4", :post)
+  end
+
+  class TestRDLAnnotate
+    extend RDL::RDLAnnotate
+
+    rdl_pre { |x| x > 0 }
+    def m1(x) return x; end
+
+    rdl_post { |x| x < 0 }
+    def m2(x) return 3; end
+
+    rdl_type '(Integer) -> Integer'
+    def m3(x) return x; end
+
+  end
+
+  def test_pre_rdl_annotate_contract
+    assert_equal 3, TestRDLAnnotate.new.m1(3)
+    assert_raises(RDL::Contract::ContractError) { TestRDLAnnotate.new.m1(-1) }
+    assert_raises(RDL::Contract::ContractError) { TestRDLAnnotate.new.m2(42) }
+    assert_raises(RDL::Type::TypeError) { TestRDLAnnotate.new.m3('one') }
+  end
+
 end

data/test/test_rdl_type.rb

@@ -3,21 +3,23 @@ $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
 
 class TestRDLType < Minitest::Test
+  extend RDL::Annotate
+
   def test_single_type_contract
     def m1(x) return x; end
-    type TestRDLType, :m1, "(Fixnum) -> Fixnum"
+    RDL.type TestRDLType, :m1, "(Integer) -> Integer"
     assert_equal 5, m1(5)
     assert_raises(RDL::Type::TypeError) { m1("foo") }
 
     self.class.class_eval {
-      type :m2, "(Fixnum) -> Fixnum"
+      type :m2, "(Integer) -> Integer"
       def m2(x) return x; end
     }
     assert_equal 5, m2(5)
     assert_raises(RDL::Type::TypeError) { m2("foo") }
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
+      type "(Integer) -> Integer"
       def m3(x) return x; end
     }
     assert_equal 5, m3(5)
@@ -26,7 +28,7 @@ class TestRDLType < Minitest::Test
 
   def test_intersection_type_contract
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
+      type "(Integer) -> Integer"
       type "(String) -> String"
       def m4(x) return x; end
     }
@@ -35,7 +37,7 @@ class TestRDLType < Minitest::Test
     assert_raises(RDL::Type::TypeError) { m4(:foo) }
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
+      type "(Integer) -> Integer"
       type "(String) -> String"
       def m5(x) return 42; end
     }
@@ -43,8 +45,8 @@ class TestRDLType < Minitest::Test
     assert_raises(RDL::Type::TypeError) { m5("foo") }
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum"
-      type "(Fixnum) -> String"
+      type "(Integer) -> Integer"
+      type "(Integer) -> String"
       def m6(x) if x > 10 then :oops elsif x > 5 then x else "small" end end
     }
     assert_equal 8, m6(8)
@@ -54,7 +56,7 @@ class TestRDLType < Minitest::Test
 
   def test_fixnum_type_contract
     self.class.class_eval {
-      type "(0) -> Fixnum"
+      type "(0) -> Integer"
       def m7(x) return x; end
     }
     assert_equal 0, m7(0)
@@ -63,9 +65,24 @@ class TestRDLType < Minitest::Test
 
   def test_wrap_new_inherited
     self.class.class_eval "class NI_A; def initialize(x); @x = x; end; end; class NI_B < NI_A; end"
-    type "TestRDLType::NI_A", "self.new", "(Fixnum) -> TestRDLType::NI_A"
+    RDL.type "TestRDLType::NI_A", "self.new", "(Integer) -> TestRDLType::NI_A"
     assert (TestRDLType::NI_B.new(3))
     assert_raises(RDL::Type::TypeError) { TestRDLType::NI_B.new("3") }
   end
 
+  def test_version
+    RDL.type "TestRDLType::TestVersion", "m1", "() -> nil", version: Gem.ruby_version.to_s
+    assert (RDL::Globals.info.has? "TestRDLType::TestVersion", "m1", :type)
+    RDL.type "TestRDLType::TestVersion", "m2", "() -> nil", version: Gem.ruby_version.bump.to_s
+    assert !(RDL::Globals.info.has? "TestRDLType::TestVersion", "m2", :type)
+  end
+
+  def test_wrap_subclass_method
+    self.class.class_eval "class NI_C; def foo; :A; end; end"
+    self.class.class_eval "class NI_D < NI_C; def foo; :B; end; end"
+    RDL.type 'TestRDLType::NI_C', :foo, '() -> :A'
+    RDL.type 'TestRDLType::NI_D', :foo, '() -> :A'
+    assert TestRDLType::NI_C.new.foo
+    assert_raises(RDL::Type::TypeError) { TestRDLType::NI_D.new.foo}
+  end
 end

data/test/test_type_contract.rb

@@ -5,16 +5,17 @@ require 'rdl'
 class TestTypeContract < Minitest::Test
   include RDL::Type
   include RDL::Contract
+  extend RDL::Annotate
 
   def setup
     @p = Parser.new
   end
 
   def test_flat
-    cnil = $__rdl_nil_type.to_contract
+    cnil = RDL::Globals.types[:nil].to_contract
     assert (cnil.check self, nil)
     assert_raises(TypeError) { cnil.check self, true }
-    tfixnum = NominalType.new :Fixnum
+    tfixnum = NominalType.new :Integer
     cfixnum = tfixnum.to_contract
     assert (cfixnum.check self, 42)
     assert (cfixnum.check self, nil)
@@ -29,7 +30,7 @@ class TestTypeContract < Minitest::Test
     p1b = t1.to_contract.wrap(self) { |x| 42 }
     assert_raises(TypeError) { p1b.call(nil) }
 
-    t2 = @p.scan_str "(Fixnum, Fixnum) -> Fixnum"
+    t2 = @p.scan_str "(Integer, Integer) -> Integer"
     p2 = t2.to_contract.wrap(self) { |x, y| x }
     assert_equal 42, p2.call(42, 43)
     assert_equal 42, p2.call(42, nil)
@@ -43,14 +44,14 @@ class TestTypeContract < Minitest::Test
     assert_nil p3.call
     assert_raises(TypeError) { p3.call(42) }
 
-    t4 = @p.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
+    t4 = @p.scan_str "(Integer, ?Integer) -> Integer"
     p4 = t4.to_contract.wrap(self) { |x| x }
     assert_equal 42, p4.call(42)
     assert_equal 42, p4.call(42, 43)
     assert_raises(TypeError) { p4.call(42, 43, 44) }
     assert_raises(TypeError) { p4.call }
 
-    t5 = @p.scan_str "(Fixnum, *Fixnum) -> Fixnum"
+    t5 = @p.scan_str "(Integer, *Integer) -> Integer"
     p5 = t5.to_contract.wrap(self) { |x| x }
     assert_equal 42, p5.call(42)
     assert_equal 42, p5.call(42, 43)
@@ -62,7 +63,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p5.call(42, 43, "44") }
     assert_raises(TypeError) { p5.call(42, 43, 44, "45") }
 
-    t6 = @p.scan_str "(Fixnum, ?Fixnum, ?Fixnum, *Fixnum) -> Fixnum"
+    t6 = @p.scan_str "(Integer, ?Integer, ?Integer, *Integer) -> Integer"
     p6 = t6.to_contract.wrap(self) { |x| x }
     assert_equal 42, p6.call(42)
     assert_equal 42, p6.call(42, 43)
@@ -76,7 +77,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p6.call(42, 43, 44, "45") }
     assert_raises(TypeError) { p6.call(42, 43, 44, 45, "46") }
 
-    t7 = @p.scan_str "(?Fixnum) -> nil"
+    t7 = @p.scan_str "(?Integer) -> nil"
     p7 = t7.to_contract.wrap(self) { nil }
     assert_nil p7.call
     assert_nil p7.call(42)
@@ -84,7 +85,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p7.call(42, 43) }
     assert_raises(TypeError) { p7.call(42, 43, 44) }
 
-    t8 = @p.scan_str "(*Fixnum) -> nil"
+    t8 = @p.scan_str "(*Integer) -> nil"
     p8 = t8.to_contract.wrap(self) { nil }
     assert_nil p8.call
     assert_nil p8.call(42)
@@ -94,26 +95,26 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p8.call(42, "43") }
     assert_raises(TypeError) { p8.call(42, 43, "44") }
 
-    t9 = @p.scan_str "(Fixnum arg1, ?Fixnum arg2) -> Fixnum"
+    t9 = @p.scan_str "(Integer arg1, ?Integer arg2) -> Integer"
     p9 = t9.to_contract.wrap(self) { |x| x }
     assert_equal 42, p9.call(42)
     assert_equal 42, p9.call(42, 43)
     assert_raises(TypeError) { p9.call(42, 43, 44) }
     assert_raises(TypeError) { p9.call }
 
-    t10 = @p.scan_str "(?Fixnum, String) -> Fixnum"
+    t10 = @p.scan_str "(?Integer, String) -> Integer"
     p10 = t10.to_contract.wrap(self) { |*args| 42 }
     assert_equal 42, p10.call("44")
     assert_equal 42, p10.call(43, "44")
     assert_raises(TypeError) { p10.call() }
     assert_raises(TypeError) { p10.call(43, "44", 45) }
 
-    t11 = @p.scan_str "(Fixnum x {{ x > 42 }}) -> Fixnum"
+    t11 = @p.scan_str "(Integer x {{ x > 42 }}) -> Integer"
     p11 = t11.to_contract.wrap(self) { |x| x }
     assert_equal 43, p11.call(43)
     assert_raises(TypeError) { p11.call(42) }
 
-    t12 = @p.scan_str "(Fixnum x {{ x>10 }}, Fixnum y {{ y > x }}) -> Fixnum z {{z > (x+y) }}"
+    t12 = @p.scan_str "(Integer x {{ x>10 }}, Integer y {{ y > x }}) -> Integer z {{z > (x+y) }}"
     p12 = t12.to_contract.wrap(self) { |x,y| x+y+1 }
     assert_equal 30, p12.call(14, 15)
     assert_equal 50, p12.call(24, 25)
@@ -124,7 +125,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p12b.call(11, 10) }
     assert_raises(TypeError) { p12b.call(9, 10) }
 
-    t13 = @p.scan_str "(Fixnum, {(Fixnum x {{x>10}}) -> Fixnum}) -> Float"
+    t13 = @p.scan_str "(Integer, {(Integer x {{x>10}}) -> Integer}) -> Float"
     p13 = t13.to_higher_contract(self) { |x,y| x+y.call(11)+0.5 }
     assert_equal 53.5, p13.call(42, Proc.new { |x| x })
     assert_raises(TypeError) { p13.call(42.5, Proc.new { |x| x} ) }
@@ -136,7 +137,7 @@ class TestTypeContract < Minitest::Test
     p13d = t13.to_higher_contract(self) { |x,y| x+y.call(42) }
     assert_raises(TypeError) { p13d.call(42, Proc.new { |x| x } ) }
 
-    t14 = @p.scan_str "(Fixnum, Fixnum) -> {(Fixnum) -> Fixnum}"
+    t14 = @p.scan_str "(Integer, Integer) -> {(Integer) -> Integer}"
     p14 = t14.to_higher_contract(self) { |x,y| Proc.new {|z| x+y+z} }
     assert_raises(TypeError) { p14.call(42.5, 42) }
     p14b = p14.call(42,42)
@@ -157,16 +158,16 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { block_contract_test4(40.5) }
     assert_raises(TypeError) { block_contract_test4(42) {|x| x+1.5} }
 
-    t15 = @p.scan_str "(Fixnum x {{x>y}}, Fixnum y) -> Fixnum"
+    t15 = @p.scan_str "(Integer x {{x>y}}, Integer y) -> Integer"
     p15 = t15.to_contract.wrap(self) { |x, y| x+y }
     assert_equal 21, p15.call(11, 10)
     assert_raises(TypeError) { p15.call(10, 11) }
 
-    t16 = @p.scan_str "(Fixnum x {{x > undefvar}}, Fixnum) -> Fixnum"
+    t16 = @p.scan_str "(Integer x {{x > undefvar}}, Integer) -> Integer"
     p16 = t16.to_contract.wrap(self) { |x,y| x }
     assert_raises(NameError) { p16.call(10,10) }
 
-    t17 = @p.scan_str "(Fixnum, *String, Fixnum) -> Fixnum"
+    t17 = @p.scan_str "(Integer, *String, Integer) -> Integer"
     p17 = t17.to_contract.wrap(self) { |x| x }
     assert_equal 42, p17.call(42, 43)
     assert_equal 42, p17.call(42, 'foo', 43)
@@ -177,7 +178,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p17.call(42, '43') }
     assert_raises(TypeError) { p17.call(42, 43, '44') }
 
-    t18 = @p.scan_str "(Fixnum, ?{(Fixnum) -> Fixnum}) -> Fixnum"
+    t18 = @p.scan_str "(Integer, ?{(Integer) -> Integer}) -> Integer"
     p18 = t18.to_higher_contract(self) { |x,p=nil| if p then p.call(x) else x end }
     assert_equal 42, p18.call(41, Proc.new {|x| x+1})
     assert_equal 42, p18.call(42)
@@ -190,29 +191,29 @@ class TestTypeContract < Minitest::Test
 
   end
 
-  type '(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum'
+  type '(Integer) { (Integer) -> Integer } -> Integer'
   def block_contract_test1(x)
     x+yield(5)
   end
 
-  type '(Fixnum) { (Fixnum) -> Fixnum } -> Float'
+  type '(Integer) { (Integer) -> Integer } -> Float'
   def block_contract_test2(x)
     x+yield(4.5)
   end
 
-  type '(Fixnum) -> Fixnum'
+  type '(Integer) -> Integer'
   def block_contract_test3(x)
     42
   end
 
-  type '(Fixnum) ?{(Fixnum) -> Fixnum} -> Fixnum'
+  type '(Integer) ?{(Integer) -> Integer} -> Integer'
   def block_contract_test4(x,&blk)
     return yield(x) if blk
     return x
   end
 
   def test_proc_names
-    t1 = @p.scan_str "(x: Fixnum) -> Fixnum"
+    t1 = @p.scan_str "(x: Integer) -> Integer"
     p1 = t1.to_contract.wrap(self) { |x:| x }
     assert_equal 42, p1.call(x: 42)
     assert_raises(TypeError) { p1.call(x: "42") }
@@ -221,7 +222,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p1.call(y: 42) }
     assert_raises(TypeError) { p1.call(42) }
     assert_raises(TypeError) { p1.call(42, x: 42) }
-    t2 = @p.scan_str "(x: Fixnum, y: String) -> Fixnum"
+    t2 = @p.scan_str "(x: Integer, y: String) -> Integer"
     p2 = t2.to_contract.wrap(self) { |x:,y:| x }
     assert_equal 42, p2.call(x: 42, y: "33")
     assert_raises(TypeError) { p2.call() }
@@ -230,7 +231,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p2.call(42, "43") }
     assert_raises(TypeError) { p2.call(42, x: 42, y: "33") }
     assert_raises(TypeError) { p2.call(x: 42, y: "33", z: 44) }
-    t3 = @p.scan_str "(Fixnum, y: String) -> Fixnum"
+    t3 = @p.scan_str "(Integer, y: String) -> Integer"
     p3 = t3.to_contract.wrap(self) { |x, y:| x }
     assert_equal 42, p3.call(42, y:"43")
     assert_raises(TypeError) { p3.call(42) }
@@ -238,7 +239,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p3.call() }
     assert_raises(TypeError) { p3.call(42, 43, y: 44) }
     assert_raises(TypeError) { p3.call(42, y: 43, z: 44) }
-    t4 = @p.scan_str "(Fixnum, x: Fixnum, y: String) -> Fixnum"
+    t4 = @p.scan_str "(Integer, x: Integer, y: String) -> Integer"
     p4 = t4.to_contract.wrap(self) { |a, x:, y:| a }
     assert_equal 42, p4.call(42, x: 43, y: "44")
     assert_raises(TypeError) { p4.call(42, x: 43) }
@@ -246,7 +247,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p4.call() }
     assert_raises(TypeError) { p4.call(42, 43, x: 44, y: "45") }
     assert_raises(TypeError) { p4.call(42, x: 43, y: "44", z: 45) }
-    t5 = @p.scan_str "(x: Fixnum, y: ?String) -> Fixnum"
+    t5 = @p.scan_str "(x: Integer, y: ?String) -> Integer"
     p5 = t5.to_contract.wrap(self) { |x:, **ys| x }
     assert_equal 42, p5.call(x: 42, y: "43")
     assert_equal 42, p5.call(x: 42)
@@ -255,7 +256,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p5.call(x: 42, y: 43, z: 44) }
     assert_raises(TypeError) { p5.call(3, x: 42, y: 43) }
     assert_raises(TypeError) { p5.call(3, x: 42) }
-    t6 = @p.scan_str "(x: ?Fixnum, y: String) -> Fixnum"
+    t6 = @p.scan_str "(x: ?Integer, y: String) -> Integer"
     p6 = t6.to_contract.wrap(self) { |y:, **xs| 42 }
     assert_equal 42, p6.call(x: 43, y: "44")
     assert_equal 42, p6.call(y: "44")
@@ -263,7 +264,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p6.call(x: "43", y: "44") }
     assert_raises(TypeError) { p6.call(42, x: 43, y: "44") }
     assert_raises(TypeError) { p6.call(x: 43, y: "44", z: 45) }
-    t7 = @p.scan_str "(x: ?Fixnum, y: ?String) -> Fixnum"
+    t7 = @p.scan_str "(x: ?Integer, y: ?String) -> Integer"
     p7 = t7.to_contract.wrap(self) { |**args| 42 }
     assert_equal 42, p7.call
     assert_equal 42, p7.call(x: 43)
@@ -272,7 +273,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p7.call(x: "43", y: "44") }
     assert_raises(TypeError) { p7.call(41, x: 43, y: "44") }
     assert_raises(TypeError) { p7.call(x: 43, y: "44", z: 45) }
-    t8 = @p.scan_str "(?Fixnum, x: ?Symbol, y: ?String) -> Fixnum"
+    t8 = @p.scan_str "(?Integer, x: ?Symbol, y: ?String) -> Integer"
     p8 = t8.to_contract.wrap(self) { |*args| 42 }
     assert_equal 42, p8.call
     assert_equal 42, p8.call(43)
@@ -285,7 +286,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p8.call(43, 44, x: :foo, y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: "foo", y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: :foo, y: "foo", z: 44) }
-    t9 = @p.scan_str "(Fixnum, x: String, y: Fixnum, **Float) -> Fixnum"
+    t9 = @p.scan_str "(Integer, x: String, y: Integer, **Float) -> Integer"
     p9 = t9.to_contract.wrap(self) { |*args| 42 }
     assert_raises(TypeError) { p9.call }
     assert_raises(TypeError) { p9.call(43) }