rdl 2.0.0.rc2 → 2.0.0.rc3

data/lib/rdl_disable.rb

@@ -0,0 +1,41 @@
+# Defines RDL methods that do nothing
+
+module RDL; end
+
+def RDL.config(*args); end
+
+class Object
+  def pre(*args); end
+  def post(*args); end
+  def type(*args); end
+  def var_type(*args); end
+  def rdl_alias(*args); end
+  def type_params(*args); end
+  def rdl_nowrap(*args); end
+  def instantaite!(*args); self; end
+  def deinstantaite!(*args); self; end
+  def type_cast(*args); self; end
+  def type_alias(*args); end
+  def rdl_do_typecheck(*args); end
+  def rdl_note_type(*args); end
+
+  def attr_accessor_type(*args)
+    args.each_slice(2) { |name, typ| attr_accessor name }
+    nil
+  end
+
+  def attr_reader_type(*args)
+    args.each_slice(2) { |name, typ| attr_reader name }
+    nil
+  end
+
+  alias_method :attr_type, :attr_reader_type
+
+  def attr_writer_type(*args)
+    args.each_slice(2) { |name, typ| attr_writer name }
+    nil
+  end
+
+
+
+end

data/lib/rdl_types.rb

@@ -1,4 +1 @@
-dir = RUBY_VERSION.split('.')[0] + ".x"
-
-require_relative "../types/ruby-#{dir}/_aliases.rb" # load type aliases first
-Dir[File.dirname(__FILE__) + "/../types/ruby-#{dir}/*.rb"].each { |f| require f }
+require_relative "types/core.rb"

data/{types/ruby-2.x → lib/types/core-ruby-2.x}/array.rb

@@ -4,82 +4,82 @@ class Array
   type_params [:t], :all?
 
   type :<<, '(t) -> Array<t>'
-  type :[], '(Range<Fixnum>) -> Array<t>'
-  type :[], '(Fixnum or Float) -> t'
-  type :[], '(Fixnum, Fixnum) -> Array<t>'
+  type :[], '(Range<%integer>) -> Array<t>'
+  type :[], '(%integer or Float) -> t'
+  type :[], '(%integer, %integer) -> Array<t>'
   type :&, '(Array<u>) -> Array<t>'
-  type :*, '(Fixnum) -> Array<t>'
+  type :*, '(%integer) -> Array<t>'
   type :*, '(String) -> String'
   type :+, '(Enumerable<u>) -> Array<u or t>'
   type :-, '(Array<u>) -> Array<u or t>'
-  type :slice, '(Range<Fixnum>) -> Array<t>'
-  type :slice, '(Fixnum) -> t'
-  type :slice, '(Fixnum, Fixnum) -> Array<t>'
-  type :[]=, '(Fixnum, t) -> t'
-  type :[]=, '(Fixnum, Fixnum, t) -> t'
-  #type :[]=, '(Fixnum, Fixnum, Array<t>) -> Array<t>'
+  type :slice, '(Range<%integer>) -> Array<t>'
+  type :slice, '(%integer) -> t'
+  type :slice, '(%integer, %integer) -> Array<t>'
+  type :[]=, '(%integer, t) -> t'
+  type :[]=, '(%integer, %integer, t) -> t'
+  #type :[]=, '(%integer, %integer, Array<t>) -> Array<t>'
   #type :[]=, '(Range, Array<t>) -> Array<t>'
-  type :[]=, '(Range<Fixnum>, t) -> t'
+  type :[]=, '(Range<%integer>, t) -> t'
   type :assoc, '(t) -> Array<t>'
-  type :at, '(Fixnum) -> t'
+  type :at, '(%integer) -> t'
   type :clear, '() -> Array<t>'
-  type :map, '() {(t) ->u} -> Array<u>'
+  type :map, '() {(t) -> u} -> Array<u>'
   type :map, '() -> Enumerator<t>'
-  type :map!, '() {(t) ->u} -> Array<u>'
+  type :map!, '() {(t) -> u} -> Array<u>'
   type :map!, '() -> Enumerator<t>'
   type :collect, '() { (t) -> u } -> Array<u>'
   type :collect, '() -> Enumerator<t>'
-  type :combination, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
-  type :combination, '(Fixnum) -> Enumerator<t>'
+  type :combination, '(%integer) { (Array<t>) -> %any } -> Array<t>'
+  type :combination, '(%integer) -> Enumerator<t>'
   type :push, '(?t) -> Array<t>'
   type :compact, '() -> Array<t>'
   type :compact!, '() -> Array<t>'
   type :concat, '(Array<t>) -> Array<t>'
-  type :count, '() -> Fixnum'
-  type :count, '(t) -> Fixnum'
-  type :count, '() { (t) -> %bool } -> Fixnum'
-  type :cycle, '(?Fixnum) { (t) -> %any } -> %any'
-  type :cycle, '(?Fixnum) -> Enumerator<t>'
+  type :count, '() -> %integer'
+  type :count, '(t) -> %integer'
+  type :count, '() { (t) -> %bool } -> %integer'
+  type :cycle, '(?%integer) { (t) -> %any } -> %any'
+  type :cycle, '(?%integer) -> Enumerator<t>'
   type :delete, '(u) -> t'
   type :delete, '(u) { () -> v } -> t or v'
-  type :delete_at, '(Fixnum) -> Array<t>'
+  type :delete_at, '(%integer) -> Array<t>'
   type :delete_if, '() { (t) -> %bool } -> Array<t>'
   type :delete_if, '() -> Enumerator<t>'
-  type :drop, '(Fixnum) -> Array<t>'
+  type :drop, '(%integer) -> Array<t>'
   type :drop_while, '() { (t) -> %bool } -> Array<t>'
   type :drop_while, '() -> Enumerator<t>'
   type :each, '() -> Enumerator<t>'
   type :each, '() { (t) -> %any } -> Array<t>'
-  type :each_index, '() { (Fixnum) -> %any } -> Array<t>'
+  type :each_index, '() { (%integer) -> %any } -> Array<t>'
   type :each_index, '() -> Enumerator<t>'
   type :empty?, '() -> %bool'
-  type :fetch, '(Fixnum) -> t'
-  type :fetch, '(Fixnum, u) -> u'
-  type :fetch, '(Fixnum) { (Fixnum) -> u } -> t or u'
+  type :fetch, '(%integer) -> t'
+  type :fetch, '(%integer, u) -> u'
+  type :fetch, '(%integer) { (%integer) -> u } -> t or u'
   type :fill, '(t) -> Array<t>'
-  type :fill, '(t,Fixnum,?Fixnum) -> Array<t>'
-  type :fill, '(t, Range<Fixnum>) -> Array<t>'
-  type :fill, '() { (Fixnum) -> t } -> Array<t>'
-  type :fill, '(Fixnum, ?Fixnum) { (Fixnum) -> t } -> Array<t>'
-  type :fill, '(Range<Fixnum>) { (Fixnum) -> t } -> Array<t>'
+  type :fill, '(t, %integer, ?%integer) -> Array<t>'
+  type :fill, '(t, Range<%integer>) -> Array<t>'
+  type :fill, '() { (%integer) -> t } -> Array<t>'
+  type :fill, '(%integer, ?%integer) { (%integer) -> t } -> Array<t>'
+  type :fill, '(Range<%integer>) { (%integer) -> t } -> Array<t>'
   type :flatten, '() -> Array<%any>' # Can't give a more precise type
-  type :index, '(u) -> Fixnum'
-  type :index, '() { (t) -> %bool } -> Fixnum'
+  type :index, '(u) -> %integer'
+  type :index, '() { (t) -> %bool } -> %integer'
   type :index, '() -> Enumerator<t>'
   type :first, '() -> t'
-  type :first, '(Fixnum) -> Array<t>'
+  type :first, '(%integer) -> Array<t>'
   type :include?, '(u) -> %bool'
-  type :insert, '(Fixnum, *t) -> Array<t>'
+  type :insert, '(%integer, *t) -> Array<t>'
   type :inspect, '() -> String'
   type :join, '(?String) -> String'
   type :keep_if, '() { (t) -> %bool } -> Array<t>'
   type :last, '() -> t'
-  type :last, '(Fixnum) -> Array<t>'
+  type :last, '(%integer) -> Array<t>'
   type :member, '(u) -> %bool'
   type :length, '() -> Fixnum'
-  type :permutation, '(?Fixnum) -> Enumerator<t>'
-  type :permutation, '(?Fixnum) { (Array<t>) -> %any } -> Array<t>'
-  type :pop, '(Fixnum) -> Array<t>'
+  type :permutation, '(?%integer) -> Enumerator<t>'
+  type :permutation, '(?%integer) { (Array<t>) -> %any } -> Array<t>'
+  type :pop, '(%integer) -> Array<t>'
   type :pop, '() -> t'
   type :product, '(*Array<u>) -> Array<Array<t or u>>'
   type :rassoc, '(u) -> t'
@@ -87,41 +87,41 @@ class Array
   type :reject, '() -> Enumerator<t>'
   type :reject!, '() { (t) -> %bool } -> Array<t>'
   type :reject!, '() -> Enumerator<t>'
-  type :repeated_combination, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
-  type :repeated_combination, '(Fixnum) -> Enumerator<t>'
-  type :repeated_permutation, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
-  type :repeated_permutation, '(Fixnum) -> Enumerator<t>'
+  type :repeated_combination, '(%integer) { (Array<t>) -> %any } -> Array<t>'
+  type :repeated_combination, '(%integer) -> Enumerator<t>'
+  type :repeated_permutation, '(%integer) { (Array<t>) -> %any } -> Array<t>'
+  type :repeated_permutation, '(%integer) -> Enumerator<t>'
   type :reverse, '() -> Array<t>'
   type :reverse!, '() -> Array<t>'
   type :reverse_each, '() { (t) -> %any } -> Array<t>'
   type :reverse_each, '() -> Enumerator<t>'
   type :rindex, '(u) -> t'
-  type :rindex, '() { (t) -> %bool } -> Fixnum'
+  type :rindex, '() { (t) -> %bool } -> %integer'
   type :rindex, '() -> Enumerator<t>'
-  type :rotate, '(?Fixnum) -> Array<t>'
-  type :rotate!, '(?Fixnum) -> Array<t>'
+  type :rotate, '(?%integer) -> Array<t>'
+  type :rotate!, '(?%integer) -> Array<t>'
   type :sample, '() -> t'
-  type :sample, '(Fixnum) -> Array<t>'
+  type :sample, '(%integer) -> Array<t>'
   type :select, '() { (t) -> %bool } -> Array<t>'
   type :select, '() -> Enumerator<t>'
   type :select!, '() { (t) -> %bool } -> Array<t>'
   type :select!, '() -> Enumerator<t>'
   type :shift, '() -> t'
-  type :shift, '(Fixnum) -> Array<t>'
+  type :shift, '(%integer) -> Array<t>'
   type :shuffle, '() -> Array<t>'
   type :shuffle!, '() -> Array<t>'
   rdl_alias :size, :length
   rdl_alias :slice, :[]
-  type :slice!, '(Range<Fixnum>) -> Array<t>'
-  type :slice!, '(Fixnum, Fixnum) -> Array<t>'
-  type :slice!, '(Fixnum or Float) -> t'
+  type :slice!, '(Range<%integer>) -> Array<t>'
+  type :slice!, '(%integer, %integer) -> Array<t>'
+  type :slice!, '(%integer or Float) -> t'
   type :sort, '() -> Array<t>'
-  type :sort, '() { (t,t) -> Fixnum } -> Array<t>'
+  type :sort, '() { (t,t) -> %integer } -> Array<t>'
   type :sort!, '() -> Array<t>'
-  type :sort!, '() { (t,t) -> Fixnum } -> Array<t>'
+  type :sort!, '() { (t,t) -> %integer } -> Array<t>'
   type :sort_by!, '() { (t) -> u } -> Array<t>'
   type :sort_by!, '() -> Enumerator<t>'
-  type :take, '(Fixnum) -> Array<t>'
+  type :take, '(%integer) -> Array<t>'
   type :take_while, '() { (t) ->%bool } -> Array<t>'
   type :take_while, '() -> Enumerator<t>'
   type :to_a, '() -> Array<t>'
@@ -131,7 +131,7 @@ class Array
   type :uniq, '() -> Array<t>'
   type :uniq!, '() -> Array<t>'
   type :unshift, '(*t) -> Array<t>'
-  type :values_at, '(*Range<Fixnum> or Fixnum) -> Array<t>'
+  type :values_at, '(*Range<%integer> or %integer) -> Array<t>'
   type :zip, '(*Array<u>) -> Array<Array<t or u>>'
   type :|, '(Array<u>) -> Array<t or u>'
 end

data/{types/ruby-2.x → lib/types/core-ruby-2.x}/float.rb

@@ -1,10 +1,10 @@
 class Float < Numeric
   rdl_nowrap
 
-  type :%, '(%integer x {{ x!=0 }}) -> Float'
-  type :%, '(Float x {{ x!=0 }}) -> Float'
-  type :%, '(Rational x {{ x!=0 }}) -> Float'
-  type :%, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
+  type :%, '(%integer x {{ x != 0 }}) -> Float'
+  type :%, '(Float x {{ x != 0 }}) -> Float'
+  type :%, '(Rational x {{ x != 0 }}) -> Float'
+  type :%, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
 
   type :*, '(%integer) -> Float'
   type :*, '(Float) -> Float'
@@ -20,7 +20,7 @@ class Float < Numeric
   pre(:**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
   post(:**) { |x| x.real?}
   type :**, '(Complex) -> Complex'
-  pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end}
+  pre(:**) { |x| x != 0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end}
 
   type :+, '(%integer) -> Float'
   type :+, '(Float) -> Float'
@@ -38,11 +38,11 @@ class Float < Numeric
 
   type :-, '() -> Float'
 
-  type :/, '(%integer x {{ x!=0 }}) -> Float'
-  type :/, '(Float x {{ x!=0 }}) -> Float'
-  type :/, '(Rational x {{ x!=0 }}) -> Float'
-  type :/, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
-  type :/, '(Complex x {{ x!=0 }}) -> Complex'
+  type :/, '(%integer x {{ x != 0 }}) -> Float'
+  type :/, '(Float x {{ x != 0 }}) -> Float'
+  type :/, '(Rational x {{ x != 0 }}) -> Float'
+  type :/, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
+  type :/, '(Complex x {{ x != 0 }}) -> Complex'
   pre(:/) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
 
   type :<, '(%integer) -> %bool'
@@ -84,13 +84,13 @@ class Float < Numeric
 
   type :abs2, '() -> Float r {{ r>=0 }}'
 
-  type :div, '(%integer x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(Float x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(Rational x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(BigDecimal x {{ x!=0 && !x.nan? && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(%integer x {{ x != 0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(Float x {{ x != 0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(Rational x {{ x != 0 && !self.infinite? && !self.nan? }}) -> %integer'
+  type :div, '(BigDecimal x {{ x != 0 && !x.nan? && !self.infinite? && !self.nan? }}) -> %integer'
 
   type :divmod, '(%real) -> [%real, %real]'
-  pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? else true end && self!=Float::INFINITY && !self.nan?}
+  pre(:divmod) { |x| x != 0 && if x.is_a?(Float) then !x.nan? else true end && self!=Float::INFINITY && !self.nan?}
 
   type :angle, '() -> %numeric'
   post(:angle) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
@@ -114,7 +114,7 @@ class Float < Numeric
   type :fdiv, '(Rational) -> Float'
   type :fdiv, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> BigDecimal'
   type :fdiv, '(Complex) -> Complex'
-  pre(:fdiv) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+  pre(:fdiv) { |x| x != 0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
 
   type :finite?, '() -> %bool'
 
@@ -132,10 +132,10 @@ class Float < Numeric
   type :magnitude, '() -> Float'
   post(:magnitude) { |r,x| r>=0 }
 
-  type :modulo, '(%integer x {{ x!=0 }}) -> Float'
-  type :modulo, '(Float x {{ x!=0 }}) -> Float'
-  type :modulo, '(Rational x {{ x!=0 }}) -> Float'
-  type :modulo, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
+  type :modulo, '(%integer x {{ x != 0 }}) -> Float'
+  type :modulo, '(Float x {{ x != 0 }}) -> Float'
+  type :modulo, '(Rational x {{ x != 0 }}) -> Float'
+  type :modulo, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
 
   type :nan?, '() -> %bool'
 
@@ -148,11 +148,11 @@ class Float < Numeric
 
   type :prev_float, '() -> Float'
 
-  type :quo, '(%integer x {{ x!=0 }}) -> Float'
-  type :quo, '(Float x {{ x!=0 }}) -> Float'
-  type :quo, '(Rational x {{ x!=0 }}) -> Float'
-  type :quo, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
-  type :quo, '(Complex x {{ x!=0 }}) -> Complex'
+  type :quo, '(%integer x {{ x != 0 }}) -> Float'
+  type :quo, '(Float x {{ x != 0 }}) -> Float'
+  type :quo, '(Rational x {{ x != 0 }}) -> Float'
+  type :quo, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> BigDecimal'
+  type :quo, '(Complex x {{ x != 0 }}) -> Complex'
   pre(:quo) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
 
   type :rationalize, '() -> Rational'
@@ -165,7 +165,7 @@ class Float < Numeric
   pre(:round) { !self.infinite? && !self.nan?}
 
   type :round, '(%numeric) -> %numeric'
-  pre(:round) { |x| x!=0 && if x.is_a?(Complex) then x.imaginary==0 && (if x.real.is_a?(Float)||x.real.is_a?(BigDecimal) then !x.real.infinite? && !x.real.nan? else true end) elsif x.is_a?(Float) then x!=Float::INFINITY && !x.nan? elsif x.is_a?(BigDecimal) then x!=BigDecimal::INFINITY && !x.nan? else true end} #Also, x must be in range [-2**31, 2**31].
+  pre(:round) { |x| x != 0 && if x.is_a?(Complex) then x.imaginary==0 && (if x.real.is_a?(Float)||x.real.is_a?(BigDecimal) then !x.real.infinite? && !x.real.nan? else true end) elsif x.is_a?(Float) then x!=Float::INFINITY && !x.nan? elsif x.is_a?(BigDecimal) then x!=BigDecimal::INFINITY && !x.nan? else true end} #Also, x must be in range [-2**31, 2**31].
 
   type :to_f, '() -> Float'
 

data/{types/ruby-2.x → lib/types/core-ruby-2.x}/integer.rb

@@ -59,13 +59,13 @@ class Integer < Numeric
   type :<=, '(BigDecimal) -> %bool'
 
   type :<=>, '(%integer) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  post(:<=>) { |r,x| r == -1 || r == 0 || r == 1 }
   type :<=>, '(Float) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  post(:<=>) { |r,x| r == -1 || r == 0 || r == 1 }
   type :<=>, '(Rational) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  post(:<=>) { |r,x| r == -1 || r == 0 || r == 1 }
   type :<=>, '(BigDecimal) -> Object'
-  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  post(:<=>) { |r,x| r == -1 || r == 0 || r == 1 }
 
   type :==, '(Object) -> %bool'
 
@@ -81,18 +81,18 @@ class Integer < Numeric
   type :>=, '(Rational) -> %bool'
   type :>=, '(BigDecimal) -> %bool'
 
-  type :>>, '(%integer) -> %integer r {{ r>=0 }}'
+  type :>>, '(%integer) -> %integer r {{ r >= 0 }}'
 
   type :[], '(%integer) -> Fixnum'
   post(:[]) { |r,x| r == 0 || r==1}
   type :[], '(Rational) -> Fixnum'
   post(:[]) { |r,x| r == 0 || r==1}
   type :[], '(Float) -> Fixnum'
-  pre(:[]) { |x| x!=Float::INFINITY && !x.nan? }
+  pre(:[]) { |x| x != Float::INFINITY && !x.nan? }
   post(:[]) { |r,x| r == 0 || r==1}
   type :[], '(BigDecimal) -> Fixnum'
-  pre(:[]) { |x| x!=BigDecimal::INFINITY && !x.nan? }
-  post(:[]) { |r,x| r == 0 || r==1}
+  pre(:[]) { |x| x != BigDecimal::INFINITY && !x.nan? }
+  post(:[]) { |r,x| r == 0 || r == 1 }
 
   type :^, '(%integer) -> %integer'
 

data/{types/ruby-2.x → lib/types/core-ruby-2.x}/kernel.rb

@@ -20,7 +20,7 @@ module Kernel
   type 'self.__dir__', '() -> String or nil'
   type 'self.__method__', '() -> Symbol or nil'
   type 'self.`', '(String) -> String'
-  type 'self.abort', '(?String msg) -> %any'
+  type 'self.abort', '(?String msg) -> %bot'
   type 'self.at_exit', '() { () -> %any} -> Proc' # TODO: Fix proc
   type 'self.autoload', '(String or Symbol module, String filename) -> nil'
   type 'self.autoload?', '(Symbol or String name) -> String or nil'
@@ -33,12 +33,12 @@ module Kernel
 #  type 'self.catch' # TODO
   type 'self.eval', '(String, ?Binding, ?String filename, ?Fixnum lineno) -> %any'
 #  type 'self.exec' #TODO
-  type 'self.exit', '(Fixnum or %bool status) -> %any'
-  type 'self.exit!', '(Fixnum or %bool status) -> %any'
-  type 'self.fail', '() -> %any'
-  type 'self.fail', '(String) -> %any'
-  type 'self.fail', '(Class, Array<String>) -> %any'
-  type 'self.fail', '(Class, String, Array<String>) -> %any'
+  type 'self.exit', '(Fixnum or %bool status) -> %bot'
+  type 'self.exit!', '(Fixnum or %bool status) -> %bot'
+  type 'self.fail', '() -> %bot'
+  type 'self.fail', '(String) -> %bot'
+  type 'self.fail', '(Class, Array<String>) -> %bot'
+  type 'self.fail', '(Class, String, Array<String>) -> %bot'
   #  type 'self.fail', '(String or [exception : () -> String], ?String, ?Array<String>) -> %any'
 #  type 'self.fork' #TODO
   type 'self.format', '(String format, *%any args) -> String'
@@ -58,7 +58,7 @@ module Kernel
   type(:proc, "() {(*%any) -> %any} -> Proc") # TODO more precise
   type 'self.putc', '(Fixnum) -> Fixnum'
   type 'self.puts', '(*[to_s : () -> String]) -> nil'
-  type 'self.raise', '() -> %any'
+  type 'self.raise', '() -> %bot'
 #  type 'self.raise', '(String or [exception : () -> String], ?String, ?Array<String>) -> %any'
 # TODO: above same as fail?
   type 'self.rand', '(Fixnum or Range max) -> Numeric'
@@ -81,9 +81,10 @@ module Kernel
 #  type 'self.trap' # TODO
 #  type 'self.untrace_var' # TODO
   type 'self.warn', '(*String msg) -> nil'
-  type :raise, '() -> nil'
-  type :raise, '(String) -> nil'
-  type :raise, '(Class, String, Array<String>) -> nil'
+  type :clone, '() -> self'
+  type :raise, '() -> %bot'
+  type :raise, '(String) -> %bot'
+  type :raise, '(Class, String, Array<String>) -> %bot'
   type :send, '(String or Symbol, *%any) -> %any'
   type :send, '(String or Symbol, *%any) { (*%any) -> %any } -> %any'
 end