rbs 0.14.0 → 0.15.0

data/stdlib/builtin/builtin.rbs

@@ -30,6 +30,25 @@ interface _Each[out A, out B]
   def each: { (A) -> void } -> B
 end
 
+interface _Reader
+  def read: (?int length, ?string outbuf) -> String?
+end
+
+interface _Writer
+  # Writes the +data+ string. Returns the number of bytes written
+  def write: (*_ToS data) -> Integer
+end
+
+interface _Rewindable
+  # Positions the stream to the beginning of input, resetting `lineno` to zero.
+  #
+  def rewind: () -> Integer
+end
+
+interface _ToIO
+  def to_io: () -> IO
+end
+
 interface _Exception
   def exception: () -> Exception
                | (String arg0) -> Exception
@@ -40,3 +59,12 @@ type real = Integer | Float | Rational
 
 type string = String | _ToStr
 type encoding = Encoding | string
+
+type io = IO | _ToIO
+
+# `boolish` is a type for documentation.
+# It means the value of this type is only for testing a condition.
+# Unlike `bool` type, it doesn't require the value is one of `true` or `false`.
+# Any Ruby object can have `boolish` type.
+#
+type boolish = top

data/stdlib/builtin/enumerable.rbs

@@ -22,7 +22,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   #     [nil, true, 99].all?                              #=> false
   #     [].all?                                           #=> true
   def all?: () -> bool
-          | () { (Elem arg0) -> untyped } -> bool
+          | () { (Elem) -> boolish } -> bool
 
   # Passes each element of the collection to the given block. The method
   # returns `true` if the block ever returns a value other than `false` or
@@ -43,7 +43,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # [].any?                                           #=> false
   # ```
   def `any?`: () -> bool
-            | () { (Elem arg0) -> untyped } -> bool
+            | () { (Elem) -> boolish } -> bool
 
   def collect: [U] () { (Elem arg0) -> U } -> ::Array[U]
              | () -> ::Enumerator[Elem, ::Array[untyped]]
@@ -62,18 +62,18 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # ary.count{ |x| x%2==0 } #=> 3
   # ```
   def count: () -> Integer
-           | (?untyped arg0) -> Integer
-           | () { (Elem arg0) -> untyped } -> Integer
+           | (?untyped) -> Integer
+           | () { (Elem) -> boolish } -> Integer
 
   def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
            | (?Integer n) -> ::Enumerator[Elem, Return]
 
-  def detect: (?Proc ifnone) { (Elem arg0) -> untyped } -> Elem?
+  def detect: (?Proc ifnone) { (Elem) -> boolish } -> Elem?
             | (?Proc ifnone) -> ::Enumerator[Elem, Return]
 
   def drop: (Integer n) -> ::Array[Elem]
 
-  def drop_while: () { (Elem arg0) -> untyped } -> ::Array[Elem]
+  def drop_while: () { (Elem) -> boolish } -> ::Array[Elem]
                 | () -> ::Enumerator[Elem, Return]
 
   def each_cons: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
@@ -96,14 +96,14 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # ```
   def entries: () -> ::Array[Elem]
 
-  def find_all: () { (Elem arg0) -> untyped } -> ::Array[Elem]
+  def find_all: () { (Elem) -> boolish } -> ::Array[Elem]
               | () -> ::Enumerator[Elem, Return]
 
   alias select find_all
   alias filter find_all
 
   def find_index: (?untyped value) -> Integer?
-                | () { (Elem arg0) -> untyped } -> Integer?
+                | () { (Elem) -> boolish } -> Integer?
                 | () -> ::Enumerator[Elem, Return]
 
   # Returns the first element, or the first `n` elements, of the enumerable.
@@ -228,7 +228,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # [nil, false, true].none?                           #=> false
   # ```
   def none?: () -> bool
-           | () { (Elem arg0) -> untyped } -> bool
+           | () { (Elem) -> boolish } -> bool
 
   # Passes each element of the collection to the given block. The method
   # returns `true` if the block returns `true` exactly once. If the block is
@@ -249,12 +249,12 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # [].one?                                            #=> false
   # ```
   def one?: () -> bool
-          | () { (Elem arg0) -> untyped } -> bool
+          | () { (Elem) -> boolish } -> bool
 
-  def partition: () { (Elem arg0) -> untyped } -> [ ::Array[Elem], ::Array[Elem] ]
+  def partition: () { (Elem) -> boolish } -> [ ::Array[Elem], ::Array[Elem] ]
                | () -> ::Enumerator[Elem, Return]
 
-  def reject: () { (Elem arg0) -> untyped } -> ::Array[Elem]
+  def reject: () { (Elem) -> boolish } -> ::Array[Elem]
             | () -> ::Enumerator[Elem, Return]
 
   def reverse_each: () { (Elem arg0) -> untyped } -> ::Enumerator[Elem, Return]
@@ -288,7 +288,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
 
   def take: (Integer n) -> ::Array[Elem]?
 
-  def take_while: () { (Elem arg0) -> untyped } -> ::Array[Elem]
+  def take_while: () { (Elem) -> boolish } -> ::Array[Elem]
                 | () -> ::Enumerator[Elem, Return]
 
   # Implemented in C++
@@ -307,11 +307,17 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # ```
   def to_h: () -> ::Hash[untyped, untyped]
 
-  def each_slice: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
+  def each_slice: (Integer n) { (::Array[Elem]) -> untyped } -> NilClass
                 | (Integer n) -> ::Enumerator[::Array[Elem], Return]
 
-  def find: (?Proc ifnone) { (Elem arg0) -> untyped } -> Elem?
-          | (?Proc ifnone) -> ::Enumerator[Elem, Return]
+  interface _NotFound[T]
+    def call: () -> T
+  end
+
+  def find: () { (Elem) -> boolish } -> Elem?
+          | () -> ::Enumerator[Elem, Elem?]
+          | [T] (_NotFound[T] ifnone) { (Elem) -> boolish } -> (Elem | T)
+          | [T] (_NotFound[T] ifnone) -> ::Enumerator[Elem, Elem | T]
 
   def flat_map: [U] () { (Elem arg0) -> U } -> U
               | () -> ::Enumerator[Elem, Return]
@@ -392,13 +398,13 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   def chunk: () -> ::Enumerator[Elem, Return]
            | [U] () { (Elem elt) -> U } -> ::Enumerator[[U, Array[Elem]], void]
 
-  def chunk_while: () { (Elem elt_before, Elem elt_after) -> bool } -> ::Enumerator[::Array[Elem], void]
+  def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]
 
-  def slice_when: () { (Elem elt_before, Elem elt_after) -> bool } -> ::Enumerator[::Array[Elem], void]
+  def slice_when: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]
 
   def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                 | () { (Elem elt) -> bool } -> ::Enumerator[::Array[Elem], void]
+                 | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]
 
   def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                  | () { (Elem elt) -> bool } -> ::Enumerator[::Array[Elem], void]
+                  | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]
 end

data/stdlib/builtin/errors.rbs

@@ -266,7 +266,7 @@ class NoMethodError[T] < NameError[T]
   #
   # *receiver* argument stores an object whose method was called.
   #
-  def initialize: (?string? msg, ?String? name, ?Array[untyped] args, ?bool `private`, ?receiver: T?) -> void
+  def initialize: (?string? msg, ?String? name, ?Array[untyped] args, ?boolish `private`, ?receiver: T?) -> void
 
   public
 

data/stdlib/builtin/gc.rbs

@@ -42,7 +42,7 @@ module GC
   # are not guaranteed to be future-compatible, and may be ignored if the
   # underlying implementation does not support them.
   #
-  def self.start: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+  def self.start: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
 
   # Returns a Hash containing information about the GC.
   #
@@ -132,7 +132,7 @@ module GC
                          | [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
                          | (Symbol key) -> untyped
 
-  def garbage_collect: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+  def garbage_collect: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
 end
 
 # internal constants

data/stdlib/builtin/hash.rbs

@@ -230,7 +230,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   def any?: () -> bool
           | (untyped pattern) -> bool
-          | () { (K, V) -> bool } -> bool
+          | () { (K, V) -> boolish } -> bool
 
   # Searches through the hash comparing *obj* with the key using `==`. Returns the
   # key-value pair (two elements array) or `nil` if no match is found.  See
@@ -360,7 +360,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = { "a" => 100, "b" => 200, "c" => 300 }
   #     h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}
   #
-  def delete_if: () { (K arg0, V arg1) -> bool } -> self
+  def delete_if: () { (K, V) -> boolish } -> self
                | () -> ::Enumerator[[ K, V ], self]
 
   # Extracts the nested value specified by the sequence of *key* objects by
@@ -498,14 +498,14 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Hash#filter is an alias for Hash#select.
   #
-  def filter: () { (K arg0, V arg1) -> bool } -> self
+  def filter: () { (K, V) -> boolish } -> self
             | () -> ::Enumerator[[ K, V ], self]
 
   # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
   #
   # Hash#filter! is an alias for Hash#select!.
   #
-  def filter!: () { (K arg0, V arg1) -> bool } -> self?
+  def filter!: () { (K, V) -> boolish } -> self?
              | () -> ::Enumerator[[ K, V ], self?]
 
   # Returns a new array that is a one-dimensional flattening of this hash. That
@@ -604,7 +604,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # See also Hash#select!.
   #
-  def keep_if: () { (K, V) -> bool } -> self
+  def keep_if: () { (K, V) -> boolish } -> self
              | () -> ::Enumerator[[ K, V ], self]
 
   # Returns the key of an occurrence of a given value. If the value is not found,
@@ -758,12 +758,12 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.reject {|k,v| v > 100}  #=> {"a" => 100}
   #
   def reject: () -> ::Enumerator[[ K, V ], self]
-            | () { (K arg0, V arg1) -> bool } -> self
+            | () { (K, V) -> boolish } -> self
 
   # Equivalent to Hash#delete_if, but returns `nil` if no changes were made.
   #
   def reject!: () -> ::Enumerator[[ K, V ], self?]
-            | () { (K arg0, V arg1) -> bool } -> self?
+            | () { (K, V) -> boolish } -> self?
 
   # Replaces the contents of *hsh* with the contents of *other_hash*.
   #

data/stdlib/builtin/io.rbs

@@ -111,7 +111,7 @@ class IO < Object
 
   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/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/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.
   #