rdl 2.0.1 → 2.1.0

data/lib/types/core/marshal.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :Marshal
+
+RDL.type :Marshal, 'self.load', '(String, ?Proc) -> Object'

data/lib/types/core/matchdata.rb

@@ -0,0 +1,24 @@
+RDL.nowrap :MatchData
+
+RDL.type :MatchData, :==, '(%any) -> %bool'
+RDL.type :MatchData, :[], '(Integer i) -> String or nil'
+RDL.type :MatchData, :[], '(Integer start, Integer length) -> Array<String>'
+RDL.type :MatchData, :[], '(Range<Integer> range) -> Array<String>'
+RDL.type :MatchData, :[], '(String or Symbol name) -> String or nil'
+RDL.type :MatchData, :begin, '(Integer n) -> Integer'
+RDL.type :MatchData, :captures, '() -> Array<String>'
+RDL.type :MatchData, :end, '(Integer n) -> Integer'
+RDL.type :MatchData, :eql?, '(%any other) -> %bool'
+RDL.type :MatchData, :hash, '() -> Integer'
+RDL.type :MatchData, :inspect, '() -> String'
+RDL.type :MatchData, :length, '() -> Integer'
+RDL.type :MatchData, :names, '() -> Array<String>'
+RDL.type :MatchData, :offset, '(Integer n) -> Array<Integer>'
+RDL.type :MatchData, :post_match, '() -> String'
+RDL.type :MatchData, :pre_match, '() -> String'
+RDL.type :MatchData, :regexp, '() -> Regexp'
+RDL.type :MatchData, :size, '() -> Integer'
+RDL.type :MatchData, :string, '() -> String'
+RDL.type :MatchData, :to_a, '() -> Array<String>'
+RDL.type :MatchData, :to_s, '() -> String'
+RDL.type :MatchData, :values_at, '(*Integer indexes) -> Array<String>'

data/lib/types/core/math.rb

@@ -0,0 +1,50 @@
+RDL.nowrap :Math
+
+RDL.type :Math, 'self.acos', '(%real x) -> Float'
+RDL.pre(:Math, 'self.acos') { |x| -1 <= x && x <= 1 }
+RDL.post(:Math, 'self.acos') { |r, _| 0 <= r && r <= Math::PI }
+RDL.type :Math, 'self.acosh', '(%real x) -> Float'
+RDL.pre(:Math, 'self.acosh') { |x| 1 <= x }
+RDL.post(:Math, 'self.acosh') { |r, _| 0 <= r }
+RDL.type :Math, 'self.asin', '(%real x) -> Float'
+RDL.pre(:Math, 'self.asin') { |x| -1 <= x && x <= 1 }
+RDL.post(:Math, 'self.asin') { |r, _| -Math::PI/2 <= r && r <= Math::PI/2 }
+RDL.type :Math, 'self.asinh', '(%real x) -> Float'
+RDL.type :Math, 'self.atan', '(%real x) -> Float'
+RDL.post(:Math, 'self.atan') { |r, _| -Math::PI/2 <= r && r <= Math::PI/2 }
+RDL.type :Math, 'self.atan2', '(%real y, %real x) -> Float'
+RDL.post(:Math, 'self.atan2') { |r, _| -Math::PI <= r && r <= Math::PI }
+RDL.type :Math, 'self.atanh', '(%real x) -> Float'
+RDL.pre(:Math, 'self.atanh') { |x| -1 < x && x < 1 }
+RDL.type :Math, 'self.cbrt', '(%real x) -> Float'
+RDL.pre(:Math, 'self.cbrt') { |x| 0 <= x }
+RDL.post(:Math, 'self.cbrt') { |x| 0 <= x }
+RDL.type :Math, 'self.cos', '(%real x) -> Float'
+RDL.post(:Math, 'self.cos') { |r, _| -1 <= r && r <= 1 }
+RDL.type :Math, 'self.cosh', '(%real x) -> Float'
+RDL.post(:Math, 'self.cosh') { |r, _| 1 <= r }
+RDL.type :Math, 'self.erf', '(%real x) -> Float'
+RDL.post(:Math, 'self.erf') { |r, _| -1 < r && r < 1 }
+RDL.type :Math, 'self.erfc', '(%real x) -> Float'
+RDL.post(:Math, 'self.erfc') { |r, _| 0 < r && r < 2 }
+RDL.type :Math, 'self.exp', '(%real x) -> Float'
+RDL.post(:Math, 'self.exp') { |r, _| 0 < r }
+RDL.type :Math, 'self.frexp', '(%real x) -> [%real, %real]'
+RDL.type :Math, 'self.gamma', '(%real x) -> Float'
+RDL.type :Math, 'self.hypot', '(%real x, %real y) -> Float'
+RDL.type :Math, 'self.ldexp', '(%real fraction, %real exponent) -> Float'
+RDL.type :Math, 'self.lgamma', '(%real x) -> -1 or 1 or Float'
+RDL.type :Math, 'self.log', '(%real x, ?(%real) base) -> Float'
+RDL.type :Math, 'self.log10', '(%real x) -> Float'
+RDL.pre(:Math, 'self.log10') { |x| 0 < x }
+RDL.type :Math, 'self.log2', '(%real x) -> Float'
+RDL.pre(:Math, 'self.log2') { |x| 0 < x }
+RDL.type :Math, 'self.sin', '(%real x) -> Float'
+RDL.post(:Math, 'self.sin') { |r, _| -1 <= r && r <= 1 }
+RDL.type :Math, 'self.sinh', '(%real x) -> Float'
+RDL.type :Math, 'self.sqrt', '(%real x) -> Float'
+RDL.pre(:Math, 'self.sqrt') { |x| 0 <= x }
+RDL.post(:Math, 'self.sqrt') { |r, _| 0 <= r }
+RDL.type :Math, 'self.tan', '(%real x) -> Float'
+RDL.type :Math, 'self.tanh', '(%real x) -> Float'
+RDL.post(:Math, 'self.tanh') { |r, _| -1 < r && r < 1 }

data/lib/types/core/module.rb

@@ -0,0 +1,81 @@
+RDL.nowrap :Module
+
+RDL.type :Module, 'self.constants', '() -> Array<Integer>' # also constants(inherited), but undocumented
+RDL.type :Module, 'self.nesting', '() -> Array<Module>'
+RDL.type :Module, :initialize, '() -> self'
+RDL.type :Module, :initialize, '() { (Module) -> %any } -> self'
+
+RDL.type :Module, :<, '(Module other) -> %bool or nil'
+RDL.type :Module, :<=, '(Module other) -> %bool or nil'
+RDL.type :Module, :<=>, '(Module other) -> -1 or 0 or 1 or nil'
+RDL.type :Module, :==, '(%any other) -> %bool'
+RDL.type :Module, :equal, '(%any other) -> %bool'
+RDL.type :Module, :eql, '(%any other) -> %bool'
+RDL.type :Module, :===, '(%any other) -> %bool'
+RDL.type :Module, :>, '(Module other) -> %bool or nil'
+RDL.type :Module, :>=, '(Module other) -> %bool or nil'
+RDL.type :Module, :ancestors, '() -> Array<Module>'
+RDL.type :Module, :autoload, '(Symbol module, String filename) -> nil'
+RDL.type :Module, :autoload?, '(Symbol name) -> String or nil'
+RDL.type :Module, :class_eval, '(String, ?String filename, ?Integer lineno) -> %any'
+RDL.type :Module, :class_exec, '(*%any args) { (*%any args) -> %any } -> %any'
+RDL.type :Module, :class_variable_defined?, '(Symbol or String) -> %bool'
+RDL.type :Module, :class_variable_get, '(Symbol or String) -> %any'
+RDL.type :Module, :class_variable_set, '(Symbol or String, %any) -> %any'
+RDL.type :Module, :class_variables, '(?%bool inherit) -> Array<Symbol>'
+RDL.type :Module, :const_defined?, '(Symbol or String, ?%bool inherit) -> %bool'
+RDL.type :Module, :const_get, '(Symbol or String, ?%bool inherit) -> %any'
+RDL.type :Module, :const_missing, '(Symbol) -> %any'
+RDL.type :Module, :const_set, '(Symbol or String, %any) -> %any'
+RDL.type :Module, :constants, '(?%bool inherit) -> Array<Symbol>'
+RDL.type :Module, :freeze, '() -> self'
+RDL.type :Module, :include, '(*Module) -> self'
+RDL.type :Module, :include?, '(Module) -> %bool'
+RDL.type :Module, :included_modules, '() -> Array<Module>'
+RDL.rdl_alias :Module, :inspect, :to_s
+RDL.type :Module, :instance_method, '(Symbol) -> UnboundMethod'
+RDL.type :Module, :instance_methods, '(?%bool include_super) -> Array<Symbol>'
+RDL.type :Module, :method_defined?, '(Symbol or String) -> %bool'
+RDL.type :Module, :module_eval, '(String, ?String filename, ?Integer lineno) -> %any' # matches rdoc example but not RDL.type
+RDL.type :Module, :module_exec, '(*%any args) { (*%any args) -> %any } -> %any'
+RDL.type :Module, :name, '() -> String'
+RDL.type :Module, :prepend, '(*Module) -> self'
+RDL.type :Module, :private_class_method, '(*(Symbol or String)) -> self'
+RDL.type :Module, :private_constant, '(*Symbol) -> self'
+RDL.type :Module, :private_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+RDL.type :Module, :private_method_defined?, '(Symbol or String) -> %bool'
+RDL.type :Module, :protected_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+RDL.type :Module, :protected_method_defined?, '(Symbol or String) -> %bool'
+RDL.type :Module, :public_class_method, '(*(Symbol or String)) -> self'
+RDL.type :Module, :public_constant, '(*Symbol) -> self'
+RDL.type :Module, :public_instance_method, '(Symbol) -> UnboundMethod'
+RDL.type :Module, :public_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+RDL.type :Module, :public_method_defined?, '(Symbol or String) -> %bool'
+RDL.type :Module, :remove_class_variable, '(Symbol) -> %any'
+RDL.type :Module, :singleton_class?, '() -> %bool'
+RDL.type :Module, :to_s, '() -> String'
+# private methods below here
+RDL.type :Module, :alias_method, '(Symbol new_name, Symbol old_name) -> self'
+RDL.type :Module, :append_features, '(Module) -> self'
+RDL.rdl_alias :Module, :attr, :attr_reader
+RDL.type :Module, :attr_accessor, '(*(Symbol or String)) -> nil'
+RDL.type :Module, :attr_reader, '(*(Symbol or String)) -> nil'
+RDL.type :Module, :attr_writer, '(*(Symbol or String)) -> nil'
+RDL.type :Module, :define_method, '(Symbol, Method) -> Symbol'
+RDL.type :Module, :define_method, '(Symbol) { (*%any) -> %any } -> Symbol'
+RDL.type :Module, :extend_object, '(%any) -> %any'
+RDL.type :Module, :extended, '(Module othermod) -> %any'
+RDL.type :Module, :included, '(Module othermod) -> %any'
+RDL.type :Module, :method_added, '(Symbol method_name) -> %any'
+RDL.type :Module, :method_removed, '(Symbol method_name) -> %any'
+RDL.type :Module, :module_function, '(*(Symbol or String)) -> self'
+RDL.type :Module, :prepend_features, '(Module) -> self'
+RDL.type :Module, :prepended, '(Module othermod) -> %any'
+RDL.type :Module, :private, '(*(Symbol or String)) -> self'
+RDL.type :Module, :protected, '(*(Symbol or String)) -> self'
+RDL.type :Module, :public, '(*(Symbol or String)) -> self'
+RDL.type :Module, :refine, '(Class) { (%any) -> %any } -> self' # ??
+RDL.type :Module, :remove_const, '(Symbol) -> %any'
+RDL.type :Module, :remove_method, '(Symbol or String) -> self'
+RDL.type :Module, :undef_method, '(Symbol or String) -> self'
+RDL.type :Module, :using, '(Module) -> self'

data/lib/types/core/nil.rb

@@ -0,0 +1,11 @@
+RDL.nowrap :NilClass
+
+RDL.type :NilClass, :&, '(%any obj) -> false'
+RDL.type :NilClass, :'^', '(%any obj) -> %bool'
+RDL.type :NilClass, :|, '(%any obj) -> %bool'
+RDL.type :NilClass, :rationalize, '() -> Rational'
+RDL.type :NilClass, :to_a, '() -> []'
+RDL.type :NilClass, :to_c, '() -> Complex'
+RDL.type :NilClass, :to_f, '() -> 0.0'
+RDL.type :NilClass, :to_h, '() -> {}'
+RDL.type :NilClass, :to_r, '() -> Rational'

data/lib/types/core/numeric.rb

@@ -0,0 +1,56 @@
+RDL.nowrap :Numeric
+
+RDL.type :Numeric, :%, '(%numeric) -> %numeric'
+RDL.pre(:Numeric, :%) { |x| x!=0}
+RDL.type :Numeric, :+, '(%numeric) -> %numeric'
+RDL.type :Numeric, :-, '() -> %numeric'
+RDL.type :Numeric, :-@, '() -> %numeric'
+RDL.type :Numeric, :+@, '() -> %numeric'
+RDL.type :Numeric, :<=>, '(%numeric) -> Object'
+RDL.post(:Numeric, :<=>) { |r,x| r == -1 || r==0 || r==1 || r==nil}
+RDL.type :Numeric, :abs, '() -> %numeric'
+RDL.post(:Numeric, :abs) { |r,x| r >= 0 }
+RDL.type :Numeric, :abs2, '() -> %numeric'
+RDL.post(:Numeric, :abs2) { |r,x| r >= 0 }
+RDL.type :Numeric, :angle, '() -> %numeric'
+RDL.type :Numeric, :arg, '() -> %numeric'
+RDL.type :Numeric, :ceil, '() -> Integer'
+RDL.type :Numeric, :coerce, '(%numeric) -> [%numeric, %numeric]'
+RDL.type :Numeric, :conj, '() -> %numeric'
+RDL.type :Numeric, :conjugate, '() -> %numeric'
+RDL.type :Numeric, :denominator, '() -> Integer'
+RDL.post(:Numeric, :denominator) { |r,x| r >= 0 }
+RDL.type :Numeric, :div, '(%numeric) -> Integer'
+RDL.pre(:Numeric, :div) { |x| x!=0}
+RDL.type :Numeric, :divmod, '(%numeric) -> [%numeric, %numeric]'
+RDL.pre(:Numeric, :divmod) { |x| x!=0 }
+RDL.type :Numeric, :eql?, '(%numeric) -> %bool'
+RDL.type :Numeric, :fdiv, '(%numeric) -> %numeric'
+RDL.type :Numeric, :floor, '() -> Integer'
+RDL.type :Numeric, :i, '() -> Complex'
+RDL.type :Numeric, :imag, '() -> %numeric'
+RDL.type :Numeric, :imaginary, '() -> %numeric'
+RDL.type :Numeric, :integer?, '() -> %bool'
+RDL.type :Numeric, :magnitude, '() -> %numeric'
+RDL.type :Numeric, :modulo, '(%numeric) -> %real'
+RDL.pre(:Numeric, :modulo) { |x| x!=0 }
+RDL.type :Numeric, :nonzero?, '() -> self or nil'
+RDL.type :Numeric, :numerator, '() -> Integer'
+RDL.type :Numeric, :phase, '() -> %numeric'
+RDL.type :Numeric, :polar, '() -> [%numeric, %numeric]'
+RDL.type :Numeric, :quo, '(%numeric) -> %numeric'
+RDL.type :Numeric, :real, '() -> %numeric'
+RDL.type :Numeric, :real?, '() -> %numeric'
+RDL.type :Numeric, :rect, '() -> [%numeric, %numeric]'
+RDL.type :Numeric, :rectangular, '() -> [%numeric, %numeric]'
+RDL.type :Numeric, :remainder, '(%numeric) -> %real'
+RDL.type :Numeric, :round, '(%numeric) -> %numeric'
+RDL.type :Numeric, :singleton_method_added, '(Symbol) -> TypeError'
+RDL.type :Numeric, :step, '(%numeric) { (%numeric) -> %any } -> %numeric'
+RDL.type :Numeric, :step, '(%numeric) -> Enumerator<%numeric>'
+RDL.type :Numeric, :step, '(%numeric, %numeric) { (%numeric) -> %any } -> %numeric'
+RDL.type :Numeric, :step, '(%numeric, %numeric) -> Enumerator<%numeric>'
+RDL.type :Numeric, :to_c, '() -> Complex'
+RDL.type :Numeric, :to_int, '() -> Integer'
+RDL.type :Numeric, :truncate, '() -> Integer'
+RDL.type :Numeric, :zero?, '() -> %bool'

data/lib/types/core/object.rb

@@ -0,0 +1,73 @@
+# Instead of rdl_nowrap, mark individual methods as not being wrapped so
+# we can wrap stuff defined by the user at the top level (since those
+# methods are added to Object).
+
+# RDL.type :ARGF, ARGF
+# RDL.type :ARGV, 'Array<String>'
+# RDL.type :DATA, 'File'
+# RDL.type :ENV, ENV
+# RDL.type :FALSE, '%false'
+# RDL.type :NIL, 'nil'
+# RDL.type :RUBY_COPYRIGHT, 'String'
+# RDL.type :RUBY_DESCRIPTION, 'String'
+# RDL.type :RUBY_ENGINE, 'String'
+# RDL.type :RUBY_PATCHLEVEL, Integer
+# RDL.type :RUBY_PLATFORM, 'String'
+# RDL.type :RUBY_RELEASE_DATE, 'String'
+# RDL.type :RUBY_REVISION, Integer
+# RDL.type :RUBY_VERSION, 'String'
+# RDL.type :STDERR, 'IO'
+# RDL.type :STDIN, 'IO'
+# RDL.type :STDOUT, 'IO'
+# RDL.type :TOPLEVEL_BINDING, 'Binding'
+# RDL.type :TRUE, '%true'
+
+RDL.type :Object, :!~, '(%any other) -> %bool', wrap: false
+RDL.type :Object, :<=>, '(%any other) -> Integer or nil', wrap: false
+RDL.type :Object, :===, '(%any other) -> %bool', wrap: false
+RDL.type :Object, :=~, '(%any other) -> nil', wrap: false
+RDL.type :Object, :class, '() -> Class', wrap: false
+RDL.type :Object, :clone, '() -> self', wrap: false
+# RDL.type :Object, :define_singleton_method, '(XXXX : *XXXX)') # TODO
+RDL.type :Object, :display, '(IO port) -> nil', wrap: false
+RDL.type :Object, :dup, '() -> self an_object', wrap: false
+RDL.type :Object, :enum_for, '(?Symbol method, *%any args) -> Enumerator<%any>', wrap: false
+RDL.type :Object, :enum_for, '(?Symbol method, *%any args) { (*%any args) -> %any } -> Enumerator<%any>', wrap: false
+RDL.type :Object, :eql?, '(%any other) -> %bool', wrap: false
+# RDL.type :Object, :extend, '(XXXX : *XXXX)') # TODO
+RDL.type :Object, :freeze, '() -> self', wrap: false
+RDL.type :Object, :frozen?, '() -> %bool', wrap: false
+RDL.type :Object, :hash, '() -> Integer', wrap: false
+RDL.type :Object, :inspect, '() -> String', wrap: false
+RDL.type :Object, :instance_of?, '(Class) -> %bool', wrap: false
+RDL.type :Object, :instance_variable_defined?, '(Symbol or String) -> %bool', wrap: false
+RDL.type :Object, :instance_variable_get, '(Symbol or String) -> %any', wrap: false
+RDL.type :Object, :instance_variable_set, '(Symbol or String, %any) -> %any', wrap: false # returns 2nd argument
+RDL.type :Object, :instance_variables, '() -> Array<Symbol>', wrap: false
+RDL.type :Object, :is_a?, '(Class or Module) -> %bool', wrap: false
+RDL.type :Object, :kind_of?, '(Class) -> %bool', wrap: false
+RDL.type :Object, :method, '(Symbol) -> Method', wrap: false
+RDL.type :Object, :methods, '(?%bool regular) -> Array<Symbol>', wrap: false
+RDL.type :Object, :nil?, '() -> %bool', wrap: false
+RDL.type :Object, :private_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+RDL.type :Object, :protected_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+RDL.type :Object, :public_method, '(Symbol) -> Method', wrap: false
+RDL.type :Object, :public_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+RDL.type :Object, :public_send, '(Symbol or String, *%any args) -> %any', wrap: false
+RDL.type :Object, :remove_instance_variable, '(Symbol) -> %any', wrap: false
+# RDL.type :Object, :respond_to?, '(Symbol or String, ?%bool include_all) -> %bool'
+RDL.type :Object, :send, '(Symbol or String, *%any args) -> %any', wrap: false # Can't wrap this, used outside wrap switch
+RDL.type :Object, :singleton_class, '() -> Class', wrap: false
+RDL.type :Object, :singleton_method, '(Symbol) -> Method', wrap: false
+RDL.type :Object, :singleton_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+RDL.type :Object, :taint, '() -> self', wrap: false
+RDL.type :Object, :tainted?, '() -> %bool', wrap: false
+# RDL.type :Object, :tap, '()') # TODO
+RDL.type :Object, :to_enum, '(?Symbol method, *%any args) -> Enumerator<%any>', wrap: false
+RDL.type :Object, :to_enum, '(?Symbol method, *%any args) {(*%any args) -> %any} -> Enumerator<%any>', wrap: false
+# TODO: above alias for enum_for?
+RDL.type :Object, :to_s, '() -> String', wrap: false
+RDL.type :Object, :trust, '() -> self', wrap: false
+RDL.type :Object, :untaint, '() -> self', wrap: false
+RDL.type :Object, :untrust, '() -> self', wrap: false
+RDL.type :Object, :untrusted?, '() -> %bool', wrap: false

data/lib/types/core/pathname.rb

@@ -0,0 +1,104 @@
+RDL.nowrap :Pathname
+
+RDL.type :Pathname, 'self.getwd', '() -> Pathname'
+RDL.type :Pathname, 'self.glob', '(String p1, ?String p2) -> Array<Pathname>'
+RDL.rdl_alias :Pathname, 'self.pwd', 'self.getwd'
+RDL.type :Pathname, :+, '(String or Pathname other) -> Pathname'
+RDL.rdl_alias :Pathname, :/, :+
+RDL.type :Pathname, :<=>, '(%any p1) -> -1 or 0 or 1 or nil'
+RDL.type :Pathname, :==, '(%any p1) -> %bool'
+RDL.type :Pathname, :===, '(%any p1) -> %bool'
+RDL.type :Pathname, :absolute?, '() -> %bool'
+RDL.type :Pathname, :ascend, '() { (Pathname) -> %any } -> %any'
+RDL.type :Pathname, :atime, '() -> Time'
+RDL.type :Pathname, :basename, '(?String p1) -> Pathname' # guessing about arg RDL.type
+RDL.type :Pathname, :binread, '(?Integer length, ?Integer offset) -> String'
+RDL.type :Pathname, :binwrite, '(String, ?Integer offset) -> Integer' # TODO open_args
+RDL.type :Pathname, :birthtime, '() -> Time'
+RDL.type :Pathname, :blockdev?, '() -> %bool'
+RDL.type :Pathname, :chardev?, '() -> %bool'
+RDL.type :Pathname, :children, '(%bool with_directory) -> Array<Pathname>'
+RDL.type :Pathname, :chmod, '(Integer mode) -> Integer'
+RDL.type :Pathname, :chown, '(Integer owner, Integer group) -> Integer'
+RDL.type :Pathname, :cleanpath, '(?%bool consider_symlink) -> %any'
+RDL.type :Pathname, :ctime, '() -> Time'
+RDL.type :Pathname, :delete, '() -> %any'
+RDL.type :Pathname, :descend, '() { (Pathname) -> %any } -> %any'
+RDL.type :Pathname, :directory?, '() -> %bool'
+RDL.type :Pathname, :dirname, '() -> Pathname'
+RDL.type :Pathname, :each_child, '(%bool with_directory) { (Pathname) -> %any } -> %any'
+RDL.type :Pathname, :each_entry, '() { (Pathname) -> %any } -> %any'
+RDL.type :Pathname, :each_filename, '() { (String) -> %any } -> %any'
+RDL.type :Pathname, :each_filename, '() -> Enumerator<String>'
+RDL.type :Pathname, :each_line, '(?String sep, ?Integer limit) { (String) -> %any } -> %any' # TODO open_args
+RDL.type :Pathname, :each_line, '(?String sep, ?Integer limit) -> Enumerator<String>'
+RDL.type :Pathname, :entries, '() -> Array<Pathname>'
+RDL.type :Pathname, :eql?, '(%any) -> %bool'
+RDL.type :Pathname, :executable?, '() -> %bool'
+RDL.type :Pathname, :executable_real?, '() -> %bool'
+RDL.type :Pathname, :exist?, '() -> %bool'
+RDL.type :Pathname, :expand_path, '(?(String or Pathname) p1) -> Pathname'
+RDL.type :Pathname, :extname, '() -> String'
+RDL.type :Pathname, :file?, '() -> %bool'
+RDL.type :Pathname, :find, '(%bool ignore_error) { (Pathname) -> %any } -> %any'
+RDL.type :Pathname, :find, '(%bool ignore_error) -> Enumerator<Pathname>'
+RDL.type :Pathname, :fnmatch, '(String pattern, ?Integer flags) -> %bool'
+RDL.type :Pathname, :freeze, '() -> self' # TODO return RDL.type?
+RDL.type :Pathname, :ftype, '() -> String'
+RDL.type :Pathname, :grpowned?, '() -> %bool'
+#RDL.type :Pathname, :initialize, '(%string or Pathname p1) -> self' # p1 can be String-like
+RDL.type :Pathname, :join, '(*(String or Pathname) args) -> Pathname'
+RDL.type :Pathname, :lchmod, '(Integer mode) -> Integer'
+RDL.type :Pathname, :lchown, '(Integer owner, Integer group) -> Integer'
+RDL.type :Pathname, :lstat, '() -> File::Stat'
+RDL.type :Pathname, :make_link, '(String old) -> 0'
+RDL.type :Pathname, :symlink, '(String old) -> 0'
+RDL.type :Pathname, :mkdir, '(String p1) -> 0'
+RDL.type :Pathname, :mkpath, '() -> %any' # TODO return?
+RDL.type :Pathname, :mountpoint?, '() -> %bool'
+RDL.type :Pathname, :mtime, '() -> Time'
+RDL.type :Pathname, :open, '(?String mode, ?String perm, ?Integer opt) -> File'
+RDL.type :Pathname, :open, '(?String mode, ?String perm, ?Integer opt) { (File) -> t } -> t'
+RDL.type :Pathname, :opendir, '(?Encoding) -> Dir'
+RDL.type :Pathname, :opendir, '(?Encoding) { (Dir) -> u } -> u'
+RDL.type :Pathname, :owned?, '() -> %bool'
+RDL.type :Pathname, :parent, '() -> Pathname'
+RDL.type :Pathname, :pipe?, '() -> %bool'
+RDL.type :Pathname, :read, '(?Integer length, ?Integer offset, ?Integer open_args) -> String'
+RDL.type :Pathname, :readable?, '() -> %bool'
+RDL.type :Pathname, :readable_real, '() -> %bool'
+RDL.type :Pathname, :readlines, '(?String sep, ?Integer limit, ?Integer open_args) -> Array<String>'
+RDL.type :Pathname, :readlink, '() -> String file'
+RDL.type :Pathname, :realdirpath, '(?String p1) -> String'
+RDL.type :Pathname, :realpath, '(?String p1) -> String'
+RDL.type :Pathname, :relative?, '() -> %bool'
+RDL.type :Pathname, :relative_path_from, '(String or Pathname base_directory) -> Pathname'
+RDL.type :Pathname, :rename, '(String p1) -> 0'
+RDL.type :Pathname, :rmdir, '() -> 0'
+RDL.type :Pathname, :rmtree, '() -> 0'
+RDL.type :Pathname, :root?, '() -> %bool'
+RDL.type :Pathname, :setgid?, '() -> %bool'
+RDL.type :Pathname, :setuid?, '() -> %bool'
+RDL.type :Pathname, :size, '() -> Integer'
+RDL.type :Pathname, :size?, '() -> %bool'
+RDL.type :Pathname, :socket?, '() -> %bool'
+RDL.type :Pathname, :split, '() -> [Pathname, Pathname]'
+RDL.type :Pathname, :stat, '() -> File::Stat'
+RDL.type :Pathname, :sticky?, '() -> %bool'
+RDL.type :Pathname, :sub, '(*String args) -> Pathname'
+RDL.type :Pathname, :sub_ext, '(String p1) -> Pathname'
+RDL.type :Pathname, :symlink?, '() -> %bool'
+RDL.type :Pathname, :sysopen, '(?Integer mode, ?Integer perm) -> Integer'
+RDL.type :Pathname, :taint, '() -> self'
+RDL.type :Pathname, :to_path, '() -> String'
+RDL.rdl_alias :Pathname, :to_s, :to_path
+RDL.type :Pathname, :truncate, '(Integer length) -> 0'
+RDL.type :Pathname, :unlink, '() -> Integer'
+RDL.type :Pathname, :untaint, '() -> self'
+RDL.type :Pathname, :utime, '(Time atime, Time mtime) -> Integer'
+RDL.type :Pathname, :world_readable?, '() -> %bool'
+RDL.type :Pathname, :world_writable?, '() -> %bool'
+RDL.type :Pathname, :writable?, '() -> %bool'
+RDL.type :Pathname, :writable_real?, '() -> %bool'
+RDL.type :Pathname, :write, '(String, ?Integer offset, ?Integer open_args) -> Integer'
+RDL.type :Pathname, :zero?, '() -> %bool'

data/lib/types/core/proc.rb

@@ -0,0 +1,12 @@
+RDL.nowrap :Proc
+
+RDL.type :Proc, :arity, '() -> Integer'
+RDL.type :Proc, :binding, '() -> Binding'
+RDL.type :Proc, :curry, '(?Integer arity) -> Proc'
+RDL.type :Proc, :hash, '() -> Integer'
+RDL.rdl_alias :Proc, :inspect, :to_s
+RDL.type :Proc, :lambda, '() -> %bool'
+RDL.type :Proc, :parameters, '() -> Array<[Symbol, Symbol]>'
+RDL.type :Proc, :source_location, '() -> [String, Integer]'
+RDL.type :Proc, :to_proc, '() -> self'
+RDL.type :Proc, :to_s, '() -> String'

data/lib/types/core/process.rb

@@ -0,0 +1,110 @@
+RDL.nowrap :Process
+
+RDL.type :Process, 'self.abort', '(?String msg) -> %any'
+RDL.type :Process, 'self.argv0', '() -> String frozen_string'
+RDL.type :Process, 'self.clock_getres', '(Symbol or Integer clock_id, ?Symbol unit) -> Float or Integer'
+RDL.type :Process, 'self.clock_gettime', '(Symbol or Integer clock_id, ?Symbol unit) -> Float or Integer'
+RDL.type :Process, 'self.daemon', '(?%any nochdir, ?%any noclose) -> 0'
+RDL.type :Process, 'self.detach', '(Integer pid) -> Thread'
+RDL.type :Process, 'self.egid', '() -> Integer'
+RDL.type :Process, 'self.egid=', '(Integer) -> Integer'
+RDL.type :Process, 'self.euid', '() -> Integer'
+RDL.type :Process, 'self.euid=', '(Integer) -> Integer user'
+  #RDL.type :Process, 'self.exec', '(env: ?Hash<String, String>, command:String, args:*String) -> %any' # TODO: env
+RDL.type :Process, 'self.exit', '(?Integer status) -> %any'
+RDL.type :Process, 'self.exit!', '(?Integer status) -> %any'
+RDL.type :Process, 'self.fork', '() -> Integer or nil'
+RDL.type :Process, 'self.fork', '() { () -> %any } -> Integer or nil'
+RDL.type :Process, 'self.getpgid', '(Integer pid) -> Integer'
+RDL.type :Process, 'self.getpgrp', '() -> Integer'
+RDL.type :Process, 'self.getpriority', '(Integer kind, Integer) -> Integer'
+RDL.type :Process, 'self.getrlimit', '(Symbol or String or Integer resource) -> [Integer, Integer] cur_max_limit'
+RDL.type :Process, 'self.getsid', '(?Integer pid) -> Integer'
+RDL.type :Process, 'self.gid', '() -> Integer'
+RDL.type :Process, 'self.gid=', '(Integer) -> Integer'
+RDL.type :Process, 'self.groups', '() -> Array<Integer>'
+RDL.type :Process, 'self.groups=', '(Array<Integer>) -> Array<Integer>'
+RDL.type :Process, 'self.initgroups', '(String username, Integer gid) -> Array<Integer>'
+RDL.type :Process, 'self.kill', '(Integer or Symbol or String signal, *Integer pids) -> Integer'
+RDL.type :Process, 'self.maxgroups', '() -> Integer'
+RDL.type :Process, 'self.maxgroups=', '(Integer) -> Integer'
+RDL.type :Process, 'self.pid', '() -> Integer'
+RDL.type :Process, 'self.ppid', '() -> Integer'
+RDL.type :Process, 'self.pgid', '(Integer pid, Integer) -> Integer'
+RDL.type :Process, 'self.setpriority', '(Integer kind, Integer, Integer priority) -> 0'
+RDL.type :Process, 'self.setproctitle', '(String) -> String'
+RDL.type :Process, 'self.setrlimit', '(Symbol or String or Integer resource, Integer cur_limit, ?Integer max_limit) -> nil'
+RDL.type :Process, 'self.setsid', '() -> Integer'
+  #RDL.type :Process, 'self.spawn', '(?Hash<String, String> env, String command, *String args) -> %any' # TODO: env
+RDL.type :Process, 'self.times', '() -> Process::Tms'
+RDL.type :Process, 'self.uid', '() -> Integer'
+RDL.type :Process, 'self.uid=', '(Integer user) -> Integer'
+RDL.type :Process, 'self.wait', '(?Integer pid, ?Integer flags) -> Integer'
+RDL.type :Process, 'self.wait2', '(?Integer pid, ?Integer flags) -> [Integer, Integer] pid_and_status'
+RDL.type :Process, 'self.waitall', '() -> Array<[Integer, Integer]>'
+RDL.type :Process, 'self.waitpid', '(?Integer pid, ?Integer flags) -> Integer'
+RDL.type :Process, 'self.waitpid2', '(?Integer pid, ?Integer flags) -> [Integer, Integer] pid_and_status'
+
+RDL.nowrap :'Process::GID'
+RDL.type :'Process::GID', 'self.change_privilege', '(Integer group) -> Integer'
+RDL.type :'Process::GID', 'self.eid', '() -> Integer'
+RDL.type :'Process::GID', 'self.from_name', '(String name) -> Integer gid'
+RDL.type :'Process::GID', 'self.grant_privilege', '(Integer group) -> Integer'
+RDL.rdl_alias :'Process::GID', 'self.eid=', 'self.grant_privilege'
+RDL.type :'Process::GID', 'self.re_exchange', '() -> Integer'
+RDL.type :'Process::GID', 'self.re_exchangeable?', '() -> %bool'
+RDL.type :'Process::GID', 'self.rid', '() -> Integer'
+RDL.type :'Process::GID', 'self.sid_available?', '() -> %bool'
+RDL.type :'Process::GID', 'self.switch', '() -> Integer'
+RDL.type :'Process::GID', 'self.switch', '() { () -> t } -> t'
+
+RDL.nowrap :'Process::UID'
+RDL.type :'Process::UID', 'self.change_privilege', '(Integer user) -> Integer'
+RDL.type :'Process::UID', 'self.eid', '() -> Integer'
+RDL.type :'Process::UID', 'self.from_name', '(String name) -> Integer uid'
+RDL.type :'Process::UID', 'self.grant_privilege', '(Integer user) -> Integer'
+RDL.rdl_alias :'Process::UID', 'self.eid=', 'self.grant_privilege'
+RDL.type :'Process::UID', 'self.re_exchange', '() -> Integer'
+RDL.type :'Process::UID', 'self.re_exchangeable?', '() -> %bool'
+RDL.type :'Process::UID', 'self.rid', '() -> Integer'
+RDL.type :'Process::UID', 'self.sid_available?', '() -> %bool'
+RDL.type :'Process::UID', 'self.switch', '() -> Integer'
+RDL.type :'Process::UID', 'self.switch', '() { () -> t } -> t'
+
+RDL.nowrap :'Process::Status'
+ RDL.type :'Process::Status', :&, '(Integer num) -> Integer'
+ RDL.type :'Process::Status', :==, '(%any other) -> %bool'
+ RDL.type :'Process::Status', :>>, '(Integer num) -> Integer'
+ RDL.type :'Process::Status', :coredump?, '() -> %bool'
+ RDL.type :'Process::Status', :exited?, '() -> %bool'
+ RDL.type :'Process::Status', :exitstatus, '() -> Integer or nil'
+ RDL.type :'Process::Status', :inspect, '() -> String'
+ RDL.type :'Process::Status', :pid, '() -> Integer'
+ RDL.type :'Process::Status', :signaled?, '() -> %bool'
+ RDL.type :'Process::Status', :stopped?, '() -> %bool'
+ RDL.type :'Process::Status', :stopsig, '() -> Integer or nil'
+ RDL.type :'Process::Status', :success?, '() -> %bool'
+ RDL.type :'Process::Status', :termsig, '() -> Integer or nil'
+ RDL.type :'Process::Status', :to_i, '() -> Integer'
+RDL.rdl_alias :'Process::Status', :to_int, :to_i
+RDL.type :'Process::Status', :to_s, '() -> String'
+
+RDL.nowrap :'Process::Sys'
+RDL.type :'Process::Sys', 'self.geteid', '() -> Integer'
+RDL.type :'Process::Sys', 'self.geteuid', '() -> Integer'
+RDL.type :'Process::Sys', 'self.getgid', '() -> Integer'
+RDL.type :'Process::Sys', 'self.getuid', '() -> Integer'
+RDL.type :'Process::Sys', 'self.issetugid', '() -> %bool'
+RDL.type :'Process::Sys', 'self.setegid', '(Integer group) -> nil'
+RDL.type :'Process::Sys', 'self.seteuid', '(Integer user) -> nil'
+RDL.type :'Process::Sys', 'self.setgid', '(Integer group) -> nil'
+RDL.type :'Process::Sys', 'self.setregid', '(Integer rid, Integer eid) -> nil'
+RDL.type :'Process::Sys', 'self.setresgid', '(Integer rid, Integer eid, Integer sid) -> nil'
+RDL.type :'Process::Sys', 'self.setresuid', '(Integer rid, Integer eid, Integer sid) -> nil'
+RDL.type :'Process::Sys', 'self.setreuid', '(Integer rid, Integer eid) -> nil'
+RDL.type :'Process::Sys', 'self.setrgid', '(Integer group) -> nil'
+RDL.type :'Process::Sys', 'self.setruid', '(Integer user) -> nil'
+RDL.type :'Process::Sys', 'self.setuid', '(Integer user) -> nil'
+
+RDL.nowrap :'Process::Waiter'
+RDL.type :'Process::Waiter', 'pid', '() -> Integer'