rbs 0.14.0 → 0.18.1

data/{stdlib/builtin → core}/io.rbs

@@ -105,13 +105,13 @@
 class IO < Object
   include File::Constants
 
-  include Enumerable[String, IO]
+  include Enumerable[String]
 
   def <<: (untyped arg0) -> self
 
   def advise: (Symbol arg0, ?Integer offset, ?Integer len) -> NilClass
 
-  def autoclose=: (bool arg0) -> bool
+  def autoclose=: (boolish) -> bool
 
   # Returns `true` if the underlying file descriptor of *ios* will be closed
   # automatically at its finalization, otherwise `false` .
@@ -141,7 +141,7 @@ class IO < Object
   # just ignored since Ruby 2.3.
   def close: () -> NilClass
 
-  def close_on_exec=: (bool arg0) -> bool
+  def close_on_exec=: (boolish) -> bool
 
   # Returns `true` if *ios* will be closed on exec.
   #
@@ -474,7 +474,7 @@ class IO < Object
   # ```
   def sync: () -> bool
 
-  def sync=: (bool arg0) -> bool
+  def sync=: (boolish) -> bool
 
   def sysread: (Integer maxlen, String outbuf) -> String
 
@@ -514,7 +514,7 @@ class IO < Object
 
   def self.binwrite: (String name, _ToS arg0, ?Integer offset, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> Integer
 
-  def self.copy_stream: (String | IO src, String | IO dst, ?Integer copy_length, ?Integer src_offset) -> Integer
+  def self.copy_stream: (_Reader src, _Writer dst, ?Integer copy_length, ?Integer src_offset) -> Integer
 
   def self.popen: (*untyped args) -> untyped
 
@@ -522,7 +522,7 @@ class IO < Object
 
   def self.readlines: (String name, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> ::Array[String]
 
-  def self.select: (::Array[IO]? read_array, ?::Array[IO]? write_array, ?::Array[IO]? error_array, ?Integer? timeout) -> ::Array[::Array[IO]]?
+  def self.select: (::Array[io]? read_array, ?::Array[io]? write_array, ?::Array[io]? error_array, ?Integer? timeout) -> ::Array[::Array[io]]?
 
   def self.sysopen: (String path, ?String mode, ?String perm) -> Integer
 

data/{stdlib/builtin → core}/kernel.rbs

@@ -71,28 +71,6 @@ module Kernel
 
   def srand: (?Numeric number) -> Numeric
 
-  def !~: (untyped other) -> bool
-
-  def <=>: (untyped other) -> Integer?
-
-  def ===: (untyped other) -> bool
-
-  def =~: (untyped other) -> NilClass
-
-  def clone: (?freeze: (TrueClass | FalseClass)) -> self
-
-  def display: (?IO port) -> NilClass
-
-  def dup: () -> self
-
-  def enum_for: (Symbol method, *untyped args) -> ::Enumerator[untyped, untyped]
-              | (Symbol method, *untyped args) { (*untyped args) -> (Integer|Float|nil) } -> ::Enumerator[untyped, untyped]
-  alias to_enum enum_for
-
-  def eql?: (untyped other) -> bool
-
-  def `extend`: (*Module mod) -> self
-
   # Creates a subprocess. If a block is specified, that block is run in the
   # subprocess, and the subprocess terminates with a status of zero.
   # Otherwise, the `fork` call returns twice, once in the parent, returning
@@ -113,70 +91,8 @@ module Kernel
   def fork: () -> Integer?
           | () { () -> untyped } -> Integer?
 
-  def freeze: () -> self
-
-  def frozen?: () -> bool
-
-  def hash: () -> Integer
-
   def initialize_copy: (self object) -> self
 
-  def inspect: () -> String
-
-  def instance_of?: (Class arg0) -> bool
-
-  def instance_variable_defined?: (Symbol | String arg0) -> bool
-
-  def instance_variable_get: (Symbol | String arg0) -> untyped
-
-  def instance_variable_set: [T] (Symbol | String arg0, T arg1) -> T
-
-  def instance_variables: () -> ::Array[Symbol]
-
-  def is_a?: (Class | Module arg0) -> bool
-  alias kind_of? is_a?
-
-  def method: (Symbol | String arg0) -> Method
-
-  def methods: (?bool regular) -> ::Array[Symbol]
-
-  def `nil?`: () -> FalseClass
-
-  def private_methods: (?bool all) -> ::Array[Symbol]
-
-  def protected_methods: (?bool all) -> ::Array[Symbol]
-
-  def public_method: (Symbol | String arg0) -> Method
-
-  def public_methods: (?bool all) -> ::Array[Symbol]
-
-  def `public_send`: (Symbol | String arg0, *untyped args) -> untyped
-                   | (Symbol | String arg0, *untyped args) { (*untyped) -> untyped } -> untyped
-
-  def remove_instance_variable: (Symbol | String arg0) -> untyped
-
-  def `send`: (String | Symbol arg0, *untyped arg1) -> untyped
-            | (String | Symbol arg0, *untyped arg1) { (*untyped) -> untyped } -> untyped
-
-  def `singleton_class`: () -> Class
-
-  def singleton_method: (Symbol | String arg0) -> Method
-
-  def singleton_methods: (?bool all) -> ::Array[Symbol]
-
-  def taint: () -> self
-  alias untrust taint
-
-  def tainted?: () -> bool
-  alias untrusted? tainted?
-
-  def tap: () { (untyped x) -> void } -> self
-
-  def to_s: () -> String
-
-  def untaint: () -> self
-  alias trust untaint
-
   # Returns `arg` as an [Array](https://ruby-doc.org/core-2.6.3/Array.html)
   # .
   #
@@ -331,7 +247,7 @@ module Kernel
   # ```
   def global_variables: () -> ::Array[Symbol]
 
-  def load: (String filename, ?bool arg0) -> bool
+  def load: (String filename, ?boolish) -> bool
 
   # Repeatedly executes the block.
   #

data/{stdlib/builtin → core}/module.rbs

@@ -237,7 +237,7 @@ class Module < Object
   #     B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
   #     B.autoload?(:CONST, false)   #=> nil, not found in B itself
   #
-  def autoload?: (Symbol name, ?bool inherit) -> String?
+  def autoload?: (Symbol name, ?boolish inherit) -> String?
 
   # Evaluates the string or block in the context of *mod*, except that when a
   # block is given, constant/class variable lookup is not affected. This can be
@@ -329,7 +329,7 @@ class Module < Object
   #     Two.class_variables          #=> [:@@var2, :@@var1]
   #     Two.class_variables(false)   #=> [:@@var2]
   #
-  def class_variables: (?bool inherit) -> ::Array[Symbol]
+  def class_variables: (?boolish inherit) -> ::Array[Symbol]
 
   # Says whether *mod* or its ancestors have a constant with the given name:
   #
@@ -364,7 +364,7 @@ class Module < Object
   #
   #     Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar
   #
-  def const_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def const_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Checks for a constant with the given name in *mod*. If `inherit` is set, the
   # lookup will also search the ancestors (and `Object` if *mod* is a `Module`).
@@ -398,7 +398,7 @@ class Module < Object
   #
   #     Object.const_get 'foobar' #=> NameError: wrong constant name foobar
   #
-  def const_get: (Symbol | String arg0, ?bool inherit) -> untyped
+  def const_get: (Symbol | String name, ?boolish inherit) -> untyped
 
   # Invoked when a reference is made to an undefined constant in *mod*. It is
   # passed a symbol for the undefined constant, and returns a value to be used for
@@ -455,7 +455,7 @@ class Module < Object
   #
   # Also see Module#const_defined?.
   #
-  def constants: (?bool inherit) -> ::Array[Symbol]
+  def constants: (?boolish inherit) -> ::Array[Symbol]
 
   # Defines an instance method in the receiver. The *method* parameter can be a
   # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
@@ -662,7 +662,7 @@ class Module < Object
   #     C.instance_methods(false)                   #=> [:method3]
   #     C.instance_methods.include?(:method2)       #=> true
   #
-  def instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Invoked as a callback whenever an instance method is added to the receiver.
   #
@@ -709,7 +709,7 @@ class Module < Object
   #     C.method_defined? "method4"             #=> false
   #     C.method_defined? "private_method2"     #=> false
   #
-  def method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Invoked as a callback whenever an instance method is removed from the
   # receiver.
@@ -881,7 +881,7 @@ class Module < Object
   #     Mod.instance_methods           #=> [:method2]
   #     Mod.private_instance_methods   #=> [:method1]
   #
-  def private_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def private_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named private method is defined by *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -906,7 +906,7 @@ class Module < Object
   #     C.private_method_defined? "method2", false   #=> false
   #     C.method_defined? "method2"                  #=> false
   #
-  def private_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def private_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # With no arguments, sets the default visibility for subsequently defined
   # methods to protected. With arguments, sets the named methods to have protected
@@ -926,7 +926,7 @@ class Module < Object
   # Returns a list of the protected instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def protected_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def protected_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named protected method is defined *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -951,7 +951,7 @@ class Module < Object
   #     C.protected_method_defined? "method2", false  #=> false
   #     C.method_defined? "method2"                   #=> true
   #
-  def protected_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def protected_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # With no arguments, sets the default visibility for subsequently defined
   # methods to public. With arguments, sets the named methods to have public
@@ -976,7 +976,7 @@ class Module < Object
   # Returns a list of the public instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def public_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def public_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named public method is defined by *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -1001,7 +1001,7 @@ class Module < Object
   #     C.public_method_defined? "method2"         #=> false
   #     C.method_defined? "method2"                #=> true
   #
-  def public_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def public_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Refine *mod* in the receiver.
   #

data/{stdlib/builtin → core}/object.rbs

@@ -631,7 +631,7 @@ class Object < BasicObject
   # When the method name parameter is given as a string, the string is converted
   # to a symbol.
   #
-  def respond_to?: (name name, ?bool include_all) -> bool
+  def respond_to?: (name name, ?boolish include_all) -> bool
 
   # Invokes the method identified by *symbol*, passing it any arguments specified.
   # You can use `__send__` if the name `send` clashes with an existing method in

data/core/object_space.rbs

@@ -0,0 +1,98 @@
+# The ObjectSpace module contains a number of routines that interact with the
+# garbage collection facility and allow you to traverse all living objects with
+# an iterator.
+#
+# ObjectSpace also provides support for object finalizers, procs that will be
+# called when a specific object is about to be destroyed by garbage collection.
+#
+#     require 'objspace'
+#
+#     a = "A"
+#     b = "B"
+#
+#     ObjectSpace.define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
+#     ObjectSpace.define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
+#
+# *produces:*
+#
+#     Finalizer two on 537763470
+#     Finalizer one on 537763480
+module ObjectSpace
+  def self._id2ref: (Integer id) -> untyped
+
+  # Counts all objects grouped by type.
+  #
+  # It returns a hash, such as:
+  #     {
+  #       :TOTAL=>10000,
+  #       :FREE=>3011,
+  #       :T_OBJECT=>6,
+  #       :T_CLASS=>404,
+  #       # ...
+  #     }
+  #
+  # The contents of the returned hash are implementation specific. It may be
+  # changed in future.
+  #
+  # The keys starting with `:T_` means live objects. For example, `:T_ARRAY` is
+  # the number of arrays. `:FREE` means object slots which is not used now.
+  # `:TOTAL` means sum of above.
+  #
+  # If the optional argument `result_hash` is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  #     h = {}
+  #     ObjectSpace.count_objects(h)
+  #     puts h
+  #     # => { :TOTAL=>10000, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249 }
+  #
+  # This method is only expected to work on C Ruby.
+  #
+  def self.count_objects: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Adds *aProc* as a finalizer, to be called after *obj* was destroyed. The
+  # object ID of the *obj* will be passed as an argument to *aProc*. If *aProc* is
+  # a lambda or method, make sure it can be called with a single argument.
+  #
+  def self.define_finalizer: (untyped obj, ^(Integer id) -> void aProc) -> [ Integer, Proc ]
+                           | (untyped obj) { (Integer id) -> void } -> [ Integer, Proc ]
+
+  # Calls the block once for each living, nonimmediate object in this Ruby
+  # process. If *module* is specified, calls the block for only those classes or
+  # modules that match (or are a subclass of) *module*. Returns the number of
+  # objects found. Immediate objects (`Fixnum`s, `Symbol`s `true`, `false`, and
+  # `nil`) are never returned. In the example below, #each_object returns both the
+  # numbers we defined and several constants defined in the Math module.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     a = 102.7
+  #     b = 95       # Won't be returned
+  #     c = 12345678987654321
+  #     count = ObjectSpace.each_object(Numeric) {|x| p x }
+  #     puts "Total count: #{count}"
+  #
+  # *produces:*
+  #
+  #     12345678987654321
+  #     102.7
+  #     2.71828182845905
+  #     3.14159265358979
+  #     2.22044604925031e-16
+  #     1.7976931348623157e+308
+  #     2.2250738585072e-308
+  #     Total count: 7
+  #
+  def self.each_object: (?Module `module`) -> Enumerator[untyped, Integer]
+                      | (?Module `module`) { (untyped obj) -> void } -> Integer
+
+  def self.garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool) -> void
+
+  # Removes all finalizers for *obj*.
+  #
+  def self.undefine_finalizer: [X] (X obj) -> X
+
+  private
+
+  def garbage_collect: (?full_mark: bool, ?immediate_mark: bool, ?immediate_sweep: bool) -> void
+end

data/{stdlib/builtin → core}/random.rbs

@@ -246,7 +246,7 @@ module Random::Formatter
   #
   # See RFC 3548 for the definition of URL-safe base64.
   #
-  def urlsafe_base64: (?Integer? n, ?bool padding) -> String
+  def urlsafe_base64: (?Integer? n, ?boolish padding) -> String
 
   # SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).
   #

data/{stdlib/builtin → core}/range.rbs

@@ -88,7 +88,7 @@
 # r.member?(Xs.new(5))       #=> true
 # ```
 class Range[out Elem] < Object
-  include Enumerable[Elem, Range[Elem]]
+  include Enumerable[Elem]
 
   def ==: (untyped obj) -> bool
 
@@ -101,7 +101,7 @@ class Range[out Elem] < Object
   # ```
   def begin: () -> Elem
 
-  def bsearch: [U] () { (Elem arg0) -> bool } -> U?
+  def bsearch: [U] () { (Elem) -> boolish } -> U?
 
   def cover?: (untyped obj) -> bool
 
@@ -144,7 +144,7 @@ class Range[out Elem] < Object
 
   def `include?`: (untyped obj) -> bool
 
-  def initialize: (Elem from, Elem to, ?bool exclude_end) -> void
+  def initialize: (Elem from, Elem to, ?boolish exclude_end) -> void
 
   # Convert this range object to a printable form (using `inspect` to
   # convert the begin and end objects).

data/{stdlib/builtin → core}/string.rbs

@@ -317,7 +317,7 @@ class String
   #     "foo".casecmp?(2)   #=> nil
   #     "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp?("\u{c4 d6 dc}")   #=> nil
   #
-  def casecmp?: (untyped other) -> bool
+  def casecmp?: (untyped other) -> bool?
 
   # Centers `str` in `width`.  If `width` is greater than the length of `str`,
   # returns a new String of length `width` with `str` centered and padded with
@@ -698,8 +698,8 @@ class String
   #     #   "o\nwor"
   #     #   "d"
   #
-  def each_line: (?string separator, ?chomp: bool) { (String line) -> void } -> self
-               | (?string separator, ?chomp: bool) -> Enumerator[String, self]
+  def each_line: (?string separator, ?chomp: boolish) { (String line) -> void } -> self
+               | (?string separator, ?chomp: boolish) -> Enumerator[String, self]
 
   # Returns `true` if *str* has a length of zero.
   #
@@ -948,7 +948,7 @@ class String
   # If a block is given, which is a deprecated form, works the same as
   # `each_line`.
   #
-  def lines: (?string separator, ?chomp: bool) -> Array[String]
+  def lines: (?string separator, ?chomp: boolish) -> Array[String]
 
   # If *integer* is greater than the length of *str*, returns a new String of
   # length *integer* with *str* left justified and padded with *padstr*;
@@ -1861,8 +1861,8 @@ class String
   #     "25".upto("5").to_a   #=> []
   #     "07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
   #
-  def upto: (string other_str, ?bool exclusive) -> Enumerator[String, self]
-          | (string other_str, ?bool exclusive) { (String s) -> void } -> self
+  def upto: (string other_str, ?boolish exclusive) -> Enumerator[String, self]
+          | (string other_str, ?boolish exclusive) { (String s) -> void } -> self
 
   # Returns true for a string which is encoded correctly.
   #