rdl 1.1.1 → 2.0.0.rc1

data/test/test_types.rb

@@ -1,19 +1,23 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestTypes < Minitest::Test
   include RDL::Type
 
+  class A; end
+  class B; end
+  class C; end
+
   def test_nil_top
-    tnil = NilType.new
-    tnil2 = NilType.new
-    assert(tnil.equal? tnil2)
-    tnil3 = NominalType.new :NilClass
-    assert(tnil.equal? tnil3)
+    tnil = NominalType.new :NilClass
+    assert_equal $__rdl_nil_type, tnil
+    tnil2 = SingletonType.new nil
+    assert_equal $__rdl_nil_type, tnil2
     ttop = TopType.new
     ttop2 = TopType.new
-    assert_same ttop, ttop2
-    assert (tnil != ttop)
+    assert_equal ttop, ttop2
+    assert ($__rdl_nil_type != ttop)
   end
 
   def test_nominal
@@ -21,8 +25,8 @@ class TestTypes < Minitest::Test
     ta2 = NominalType.new :A
     ta3 = NominalType.new "A"
     tb = NominalType.new :B
-    assert_same ta, ta2
-    assert_same ta, ta3
+    assert_equal ta, ta2
+    assert_equal ta, ta3
     assert (ta != tb)
     assert_equal "A", ta.name
   end
@@ -32,7 +36,7 @@ class TestTypes < Minitest::Test
     ta2 = SingletonType.new :A
     tb = SingletonType.new :B
     tan = NominalType.new :A
-    assert_same ta, ta2
+    assert_equal ta, ta2
     assert (ta != tb)
     assert_equal :A, ta.val
     assert (ta != tan)
@@ -44,36 +48,34 @@ class TestTypes < Minitest::Test
     ta3 = VarType.new "A"
     tb = VarType.new :B
     tan = NominalType.new :A
-    assert_same ta, ta2
-    assert_same ta, ta3
+    assert_equal ta, ta2
+    assert_equal ta, ta3
     assert (ta != tb)
     assert_equal :A, ta.name
     assert (ta != tan)
   end
 
   def u_or_i(c)
-    tnil = NilType.new
-    ttop = TopType.new
-    ta = NominalType.new :A
-    tb = NominalType.new :B
-    tc = NominalType.new :C
+    ta = NominalType.new A
+    tb = NominalType.new B
+    tc = NominalType.new C
     t1 = c.new ta, tb
     assert_equal 2, t1.types.length
     t2 = c.new tb, ta
-    assert_same t1, t2
-    t3 = c.new ttop, ttop
-    assert_same t3, ttop
-    t4 = c.new ttop, tnil, ttop, tnil
-    assert_same t4, ttop
-    t5 = c.new tnil, tnil
-    assert_same t5, tnil
+    assert_equal t1, t2
+    t3 = c.new $__rdl_top_type, $__rdl_top_type
+    assert_equal t3, $__rdl_top_type
+    t4 = c.new $__rdl_top_type, $__rdl_nil_type, $__rdl_top_type, $__rdl_nil_type
+    assert_equal t4, $__rdl_top_type
+    t5 = c.new $__rdl_nil_type, $__rdl_nil_type
+    assert_equal t5, $__rdl_nil_type
     t6 = c.new ta, tb, tc
     assert_equal 3, t6.types.length
     t7 = c.new ta, (c.new tb, tc)
-    assert_same t6, t7
+    assert_equal t6, t7
     t8 = c.new (c.new tc, tb), (c.new ta)
-    assert_same t6, t8
-    assert (t1 != tnil)
+    assert_equal t6, t8
+    assert (t1 != $__rdl_nil_type)
   end
 
   def test_union_intersection
@@ -82,37 +84,34 @@ class TestTypes < Minitest::Test
   end
 
   def test_optional
-    tnil = NilType.new
     ta = NominalType.new :A
-    t1 = OptionalType.new tnil
-    assert_equal tnil, t1.type
-    t2 = OptionalType.new tnil
-    assert_same t1, t2
+    t1 = OptionalType.new $__rdl_nil_type
+    assert_equal $__rdl_nil_type, t1.type
+    t2 = OptionalType.new $__rdl_nil_type
+    assert_equal t1, t2
     t3 = OptionalType.new ta
     assert (t1 != t3)
   end
 
   def test_vararg
-    tnil = NilType.new
     ta = NominalType.new :A
-    t1 = VarargType.new tnil
-    assert_equal tnil, t1.type
-    t2 = VarargType.new tnil
-    assert_same t1, t2
+    t1 = VarargType.new $__rdl_nil_type
+    assert_equal $__rdl_nil_type, t1.type
+    t2 = VarargType.new $__rdl_nil_type
+    assert_equal t1, t2
     t3 = VarargType.new ta
     assert (t1 != t3)
   end
 
   def test_method
-    tnil = NilType.new
     ta = NominalType.new :A
     tb = NominalType.new :B
     tc = NominalType.new :C
-    t1 = MethodType.new [ta, tb, tc], nil, tnil
+    t1 = MethodType.new [ta, tb, tc], nil, $__rdl_nil_type
     assert_equal [ta, tb, tc], t1.args
     assert_nil t1.block
-    assert_equal tnil, t1.ret
-    t2 = MethodType.new [tnil], t1, tnil
+    assert_equal $__rdl_nil_type, t1.ret
+    t2 = MethodType.new [$__rdl_nil_type], t1, $__rdl_nil_type
     assert_equal t1, t2.block
   end
 
@@ -124,7 +123,7 @@ class TestTypes < Minitest::Test
     assert_equal thash, t1.base
     assert_equal [ta, tb], t1.params
     t2 = GenericType.new thash, ta, tb
-    assert_same t1, t2
+    assert_equal t1, t2
     t3 = GenericType.new thash, tb, ta
     assert (t1 != t3)
     tavar = VarType.new :a
@@ -134,11 +133,10 @@ class TestTypes < Minitest::Test
   end
 
   def test_structural
-    tnil = NilType.new
     ta = NominalType.new :A
     tb = NominalType.new :B
     tc = NominalType.new :C
-    tm1 = MethodType.new [ta, tb, tc], nil, tnil
+    tm1 = MethodType.new [ta, tb, tc], nil, $__rdl_nil_type
     tm2 = MethodType.new [ta], tm1, tb
     t1 = StructuralType.new(m1: tm1, m2: tm2)
     assert_equal tm1, t1.methods[:m1]
@@ -158,10 +156,8 @@ class TestTypes < Minitest::Test
   end
 
   def test_instantiate
-    tnil = NilType.new
-    ttop = TopType.new
-    tA = NominalType.new :A
-    tB = NominalType.new :B
+    tA = NominalType.new A
+    tB = NominalType.new B
     toptionalA = OptionalType.new tA
     tvarargA = VarargType.new tA
     tannotatedA = AnnotatedArgType.new("arg", tA)
@@ -188,15 +184,15 @@ class TestTypes < Minitest::Test
     tmethAAB = MethodType.new([tA, tA], nil, tB)
     tmethaab = MethodType.new([ta, ta], nil, tb)
     tmethstringstringfixnum = MethodType.new([tstring, tstring], nil, tfixnum)
-    tmethbAABn = MethodType.new([], tmethAAB, tnil)
-    tmethbaabn = MethodType.new([], tmethaab, tnil)
-    tmethbssfn = MethodType.new([], tmethstringstringfixnum, tnil)
+    tmethbAABn = MethodType.new([], tmethAAB, $__rdl_nil_type)
+    tmethbaabn = MethodType.new([], tmethaab, $__rdl_nil_type)
+    tmethbssfn = MethodType.new([], tmethstringstringfixnum, $__rdl_nil_type)
     tstructorig = StructuralType.new(m1: tmethAAB, m2: tmethaab,
                                      m3: tmethbAABn, m4: tmethbaabn)
     tstructinst = StructuralType.new(m1: tmethAAB, m2: tmethstringstringfixnum,
                                      m3: tmethbAABn, m4: tmethbssfn)
-    assert_equal tnil, tnil.instantiate(inst)
-    assert_equal ttop, ttop.instantiate(inst)
+    assert_equal $__rdl_nil_type, $__rdl_nil_type.instantiate(inst)
+    assert_equal $__rdl_top_type, $__rdl_top_type.instantiate(inst)
     assert_equal tA, tA.instantiate(inst)
     assert_equal toptionalA, toptionalA.instantiate(inst)
     assert_equal tvarargA, tvarargA.instantiate(inst)

data/test/test_wrap.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestWrap < Minitest::Test
   class C

data/types/ruby-2.x/_aliases.rb

@@ -1,4 +1,15 @@
-type_alias '%real', 'Integer or Float or Rational or BigDecimal'
+if defined? BigDecimal
+  type_alias '%real', 'Fixnum or Bignum or Float or Rational or BigDecimal'
+  type_alias '%numeric', 'Fixnum or Bignum or Float or Rational or BigDecimal or Complex'
+else
+  type_alias '%real', 'Fixnum or Bignum or Float or Rational'
+  type_alias '%numeric', 'Fixnum or Bignum or Float or Rational'
+end
 type_alias '%string', '[to_str: () -> String]'
-type_alias '%path', '%string or Pathname'
+type_alias '%integer', 'Fixnum or Bignum'
+if defined? Pathname
+  type_alias '%path', '%string or Pathname'
+else
+  type_alias '%path', '%string'
+end
 type_alias '%open_args', '{external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any, mode: ?String}'

data/types/ruby-2.x/bigdecimal.rb

@@ -1,20 +1,18 @@
 class BigDecimal < Numeric
   rdl_nowrap
 
-  type :%, '(Numeric) -> BigDecimal'
+  type :%, '(%numeric) -> BigDecimal'
   pre(:%) { |x| x!=0&&(if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end)}
 
-  type :+, '(Integer) -> BigDecimal'
-  type :+, '(Float) -> BigDecimal'
-  pre(:+) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :+, '(%integer) -> BigDecimal'
+  type :+, '(Float x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
   type :+, '(Rational) -> BigDecimal'
   type :+, '(BigDecimal) -> BigDecimal'
   type :+, '(Complex) -> Complex'
   pre(:+) { |x| if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end}
 
-  type :-, '(Integer) -> BigDecimal'
-  type :-, '(Float) -> BigDecimal'
-  pre(:-) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :-, '(%integer) -> BigDecimal'
+  type :-, '(Float x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
   type :-, '(Rational) -> BigDecimal'
   type :-, '(BigDecimal) -> BigDecimal'
   type :-, '(Complex) -> Complex'
@@ -22,15 +20,14 @@ class BigDecimal < Numeric
 
   type :-, '() -> BigDecimal'
 
-  type :*, '(Integer) -> BigDecimal'
-  type :*, '(Float) -> BigDecimal'
-  pre(:*) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :*, '(%integer) -> BigDecimal'
+  type :*, '(Float x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
   type :*, '(Rational) -> BigDecimal'
   type :*, '(BigDecimal) -> BigDecimal'
   type :*, '(Complex) -> Complex'
   pre(:*) { |x| if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end}
 
-  type :**, '(Integer) -> BigDecimal'
+  type :**, '(%integer) -> BigDecimal'
   type :**, '(Float) -> BigDecimal'
   pre(:**) { |x| x!=Float::INFINITY && !x.nan? && if(self<0) then x<=-1||x>=0 else true end}
   type :**, '(Rational) -> BigDecimal'
@@ -38,38 +35,30 @@ class BigDecimal < Numeric
   type :**, '(BigDecimal) -> BigDecimal'
   pre(:**) { |x| x!=BigDecimal::INFINITY && if(self<0) then x<=-1||x>=0 else true end}
 
-  type :/, '(Integer) -> BigDecimal'
-  pre(:/) { |x| x!=0}
-  type :/, '(Float) -> BigDecimal'
-  pre(:/) { |x| x!=0 && x!=Float::INFINITY && !(x.nan?)}
-  type :/, '(Rational) -> BigDecimal'
-  pre(:/) { |x| x!=0}
-  type :/, '(BigDecimal) -> BigDecimal'
-  pre(:/) { |x| x!=0}
-  type :/, '(Complex) -> Complex'
-  pre(:/) { |x| x!=0 && if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end && if x.imaginary.is_a?(Float) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end && if (x.real.is_a?(Rational)) then !x.imaginary.nan? else true end}
-
-  type :<, '(Integer) -> %bool'
-  type :<, '(Float) -> %bool'
-  pre(:<) { |x| !x.nan? && x!=Float::INFINITY}
+  type :/, '(%integer x {{ x!=0 }}) -> BigDecimal'
+  type :/, '(Float x {{ x!=0 && !x.infinite? && !x.nan? }}) -> BigDecimal'
+  type :/, '(Rational x {{ x!=0 }}) -> BigDecimal'
+  type :/, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+  type :/, '(Complex x {{ x!=0 }}) -> Complex'
+  pre(:/) { |x| if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end && if x.imaginary.is_a?(Float) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end && if (x.real.is_a?(Rational)) then !x.imaginary.nan? else true end}
+
+  type :<, '(%integer) -> %bool'
+  type :<, '(Float x {{ !x.nan? && !x.infinite? }}) -> %bool'
   type :<, '(Rational) -> %bool'
   type :<, '(BigDecimal) -> %bool'
 
-  type :<=, '(Integer) -> %bool'
-  type :<=, '(Float) -> %bool'
-  pre(:<=) { |x| !x.nan? && x!=Float::INFINITY}
+  type :<=, '(%integer) -> %bool'
+  type :<=, '(Float x {{ !x.nan? && !x.infinite }}) -> %bool'
   type :<=, '(Rational) -> %bool'
   type :<=, '(BigDecimal) -> %bool'
 
-  type :>, '(Integer) -> %bool'
-  type :>, '(Float) -> %bool'
-  pre(:>) { |x| !x.nan? && x!=Float::INFINITY}
+  type :>, '(%integer) -> %bool'
+  type :>, '(Float x {{ !x.nan? && !x.infinite? }}) -> %bool'
   type :>, '(Rational) -> %bool'
   type :>, '(BigDecimal) -> %bool'
 
-  type :>=, '(Integer) -> %bool'
-  type :>=, '(Float) -> %bool'
-  pre(:>=) { |x| !x.nan? && x!=Float::INFINITY}
+  type :>=, '(%integer) -> %bool'
+  type :>=, '(Float x {{ !x.nan? && !x.infinite? }}) -> %bool'
   type :>=, '(Rational) -> %bool'
   type :>=, '(BigDecimal) -> %bool'
 
@@ -79,7 +68,7 @@ class BigDecimal < Numeric
   type :===, '(Object) -> %bool'
   pre(:===) { |x| if (x.is_a?(Float)) then (!x.nan? && x!=Float::INFINITY) else true end}
 
-  type :<=>, '(Integer) -> Object'
+  type :<=>, '(%integer) -> Object'
   post(:<=>) { |r,x| r == -1 || r==0 || r==1}
   type :<=>, '(Float) -> Object'
   pre(:<=>) { |x| !x.nan? && x!=Float::INFINITY}
@@ -89,38 +78,31 @@ class BigDecimal < Numeric
   type :<=>, '(BigDecimal) -> Object'
   post(:<=>) { |r,x| r == -1 || r==0 || r==1}
 
-  type :abs, '() -> BigDecimal'
-  post(:abs) { |r,x| r >= 0 }
+  type :abs, '() -> BigDecimal r {{ r>=0 }}'
 
-  type :abs2, '() -> BigDecimal'
-  post(:abs2) { |r,x| r >= 0 }
+  type :abs2, '() -> BigDecimal r {{ r>=0 }}'
 
-  type :angle, '() -> Numeric'
+  type :angle, '() -> %numeric'
   post(:angle) { |r,x| r == 0 || r == Math::PI}
 
-  type :arg, '() -> Numeric'
+  type :arg, '() -> %numeric'
   post(:arg) { |r,x| r == 0 || r == Math::PI}
 
-  type :ceil, '() -> Integer'
+  type :ceil, '() -> %integer'
   pre(:ceil) { !self.ininite? && !self.nan?}
 
   type :conj, '() -> BigDecimal'
   type :conjugate, '() -> BigDecimal'
 
-  type :denominator, '() -> Integer'
+  type :denominator, '() -> %integer'
   pre(:denominator) { !self.ininite? && !self.nan?}
   post(:denominator) { |r,x| r>0}
 
-  type :div, '(Fixnum) -> Integer'
-  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
-  type :div, '(Bignum) -> Integer'
-  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
-  type :div, '(Float) -> Integer'
-  pre(:div) { |x| x!=0 && !x.nan? && x!=Float::INFINITY && !self.infinite? && !self.nan?}
-  type :div, '(Rational) -> Integer'
-  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
-  type :div, '(BigDecimal) -> Integer'
-  pre(:div) { |x| x!=0 && !x.nan? && !self.infinite? && !self.nan?}
+  type :div, '(Fixnum x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(Bignum x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(Float x {{ x!=0 && !self.infinite? && !self.nan? && !x.infinite? && !x.nan? }}) -> %integer'
+  type :div, '(Rational x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? && !x.infinite? && !x.nan? }}) -> %integer'
 
   type :divmod, '(%real) -> [%real, %real]'
   pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? && x!=Float::INFINITY else true end}
@@ -128,7 +110,7 @@ class BigDecimal < Numeric
   type :equal?, '(Object) -> %bool'
   type :eql?, '(Object) -> %bool'
 
-  type :fdiv, '(Integer) -> Float'
+  type :fdiv, '(%integer) -> Float'
   type :fdiv, '(Float) -> Float'
   type :fdiv, '(Rational) -> Float'
   type :fdiv, '(BigDecimal) -> BigDecimal'
@@ -137,50 +119,43 @@ class BigDecimal < Numeric
 
   type :finite?, '() -> %bool'
 
-  type :floor, '() -> Integer'
+  type :floor, '() -> %integer'
   pre(:floor) { !self.infinite? && !self.nan?}
 
-  type :hash, '() -> Integer'
+  type :hash, '() -> %integer'
 
-  type :imag, '() -> Fixnum'
-  post(:imag) { |r,x| r == 0 }
-  type :imaginary, '() -> Fixnum'
-  post(:imaginary) { |r,x| r == 0 }
+  type :imag, '() -> Fixnum r {{ r==0 }}'
+  type :imaginary, '() -> Fixnum r {{ r==0 }}'
 
   type :infinite?, '() -> %bool'
 
   type :to_s, '() -> String'
   type :inspect, '() -> String'
 
-  type :magnitude, '() -> BigDecimal'
-  post(:magnitude) { |r,x| r>0}
+  type :magnitude, '() -> BigDecimal r {{ r>=0 }}'
 
-  type :modulo, '(Numeric) -> BigDecimal'
+  type :modulo, '(%numeric) -> BigDecimal'
   pre(:modulo) { |x| x!=0&&(if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end)}
 
   type :nan?, '() -> %bool'
 
-  type :numerator, '() -> Integer'
+  type :numerator, '() -> %integer'
   pre(:numerator) { !self.infinite? && !self.nan?}
 
-  type :phase, '() -> Numeric'
+  type :phase, '() -> %numeric'
 
-  type :quo, '(Integer) -> BigDecimal'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(Float) -> BigDecimal'
-  pre(:quo) { |x| x!=0 && x!=Float::INFINITY && !x.nan?}
-  type :quo, '(Rational) -> BigDecimal'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(BigDecimal) -> BigDecimal'
-  pre(:quo) { |x| x!=0}
+  type :quo, '(%integer x {{ x!=0 }}) -> BigDecimal'
+  type :quo, '(Float x {{ x!=0 && !x.infinite? && !x.nan?}}) -> BigDecimal'
+  type :quo, '(Rational x {{ x!=0 }}) -> BigDecimal'
+  type :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
   type :quo, '(Complex) -> Complex'
   pre(:quo) { |x| x!=0 && if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end && if x.imaginary.is_a?(Float) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end && if (x.real.is_a?(Rational)) then !x.imaginary.nan? else true end}
 
   type :real, '() -> BigDecimal'
 
-  type :real?, '() -> TrueClass'
+  type :real?, '() -> true'
 
-  type :round, '() -> Integer' 
+  type :round, '() -> %integer'
   pre(:round) { !self.infinite? && !self.nan?}
 
   type :round, '(Fixnum) -> BigDecimal' #Also, x must be in range [-2**31, 2**31].
@@ -188,26 +163,26 @@ class BigDecimal < Numeric
   type :to_f, '() -> Float'
   pre(:to_f) { self<=Float::MAX}
 
-  type :to_i, '() -> Integer' 
+  type :to_i, '() -> %integer'
   pre(:to_i) { !self.infinite? && !self.nan?}
-  type :to_int, '() -> Integer'
+  type :to_int, '() -> %integer'
   pre(:to_int) { !self.infinite? && !self.nan?}
 
   type :to_r, '() -> Rational'
   pre(:to_r) { !self.infinite? && !self.nan?}
 
-  type :to_c, '() -> Complex'
+  type :to_c, '() -> Complex r {{ r.imaginary == 0 }}'
   post(:to_c) { |r,x| r.imaginary == 0 }
 
-  type :truncate, '() -> Integer'
+  type :truncate, '() -> %integer'
 
   type :truncate, '(Fixnum) -> Rational' #Also, x must be in range [-2**31, 2**31].
 
   type :zero?, '() -> %bool'
 
-  type :precs, '() -> [Integer, Integer]'
+  type :precs, '() -> [%integer, %integer]'
 
-  type :split, '() -> [Fixnum, String, Integer, Integer]'
+  type :split, '() -> [Fixnum, String, %integer, %integer]'
 
   type :remainder, '(%real) -> BigDecimal'
   pre(:remainder) { |x| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
@@ -216,7 +191,7 @@ class BigDecimal < Numeric
 
   type :frac, '() -> BigDecimal'
 
-  type :power, '(Integer) -> BigDecimal'
+  type :power, '(%integer) -> BigDecimal'
   type :power, '(Float) -> BigDecimal'
   pre(:power) { |x| x!=Float::INFINITY && !x.nan? && if(self<0) then x<=-1||x>=0 else true end}
   type :power, '(Rational) -> BigDecimal'
@@ -226,7 +201,7 @@ class BigDecimal < Numeric
 
   type :nonzero?, '() -> Object'
 
-  type :exponent, '() -> Integer'
+  type :exponent, '() -> %integer'
 
   type :sign, '() -> Fixnum'
 
@@ -237,13 +212,13 @@ class BigDecimal < Numeric
 
   type :add, '(%real, Fixnum) -> BigDecimal'
   pre(:add) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
-  
+
   type :sub, '(%real, Fixnum) -> BigDecimal'
   pre(:sub) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
 
   type :mult, '(%real, Fixnum) -> BigDecimal'
   pre(:mult) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
-  
+
   type :coerce, '(%real) -> [BigDecimal, BigDecimal]'
   pre(:coerce) { |x| if x.is_a?(Float) then !x.nan? && !x.finite? else true end}
 end