rbs 2.8.4 → 3.8.1

data/core/kernel.rbs

@@ -12,266 +12,135 @@
 #
 # Module Kernel provides methods that are useful for:
 #
-# *   [Converting](#module-Kernel-label-Converting)
-# *   [Querying](#module-Kernel-label-Querying)
-# *   [Exiting](#module-Kernel-label-Exiting)
-# *   [Exceptions](#module-Kernel-label-Exceptions)
-# *   [IO](#module-Kernel-label-IO)
-# *   [Procs](#module-Kernel-label-Procs)
-# *   [Tracing](#module-Kernel-label-Tracing)
-# *   [Subprocesses](#module-Kernel-label-Subprocesses)
-# *   [Loading](#module-Kernel-label-Loading)
-# *   [Yielding](#module-Kernel-label-Yielding)
-# *   [Random Values](#module-Kernel-label-Random+Values)
-# *   [Other](#module-Kernel-label-Other)
-#
+# *   [Converting](rdoc-ref:Kernel@Converting)
+# *   [Querying](rdoc-ref:Kernel@Querying)
+# *   [Exiting](rdoc-ref:Kernel@Exiting)
+# *   [Exceptions](rdoc-ref:Kernel@Exceptions)
+# *   [IO](rdoc-ref:Kernel@IO)
+# *   [Procs](rdoc-ref:Kernel@Procs)
+# *   [Tracing](rdoc-ref:Kernel@Tracing)
+# *   [Subprocesses](rdoc-ref:Kernel@Subprocesses)
+# *   [Loading](rdoc-ref:Kernel@Loading)
+# *   [Yielding](rdoc-ref:Kernel@Yielding)
+# *   [Random Values](rdoc-ref:Kernel@Random+Values)
+# *   [Other](rdoc-ref:Kernel@Other)
 #
 # ### Converting
 #
-#     [#Array](#method-i-Array)
-# :       Returns an Array based on the given argument.
-#
-#     [#Complex](#method-i-Complex)
-# :       Returns a Complex based on the given arguments.
-#
-#     [#Float](#method-i-Float)
-# :       Returns a Float based on the given arguments.
-#
-#     [#Hash](#method-i-Hash)
-# :       Returns a Hash based on the given argument.
-#
-#     [#Integer](#method-i-Integer)
-# :       Returns an Integer based on the given arguments.
-#
-#     [#Rational](#method-i-Rational)
-# :       Returns a Rational based on the given arguments.
-#
-#     [#String](#method-i-String)
-# :       Returns a String based on the given argument.
-#
-#
+# *   #Array: Returns an Array based on the given argument.
+# *   #Complex: Returns a Complex based on the given arguments.
+# *   #Float: Returns a Float based on the given arguments.
+# *   #Hash: Returns a Hash based on the given argument.
+# *   #Integer: Returns an Integer based on the given arguments.
+# *   #Rational: Returns a Rational based on the given arguments.
+# *   #String: Returns a String based on the given argument.
 #
 # ### Querying
 #
-#     [#__callee__](#method-i-__callee__)
-# :       Returns the called name of the current method as a symbol.
-#
-#     [#__dir__](#method-i-__dir__)
-# :       Returns the path to the directory from which the current method is
-#         called.
-#
-#     [#__method__](#method-i-__method__)
-# :       Returns the name of the current method as a symbol.
-#
-#     #autoload?
-# :       Returns the file to be loaded when the given module is referenced.
-#
-#     #binding
-# :       Returns a Binding for the context at the point of call.
-#
-#     #block_given?
-# :       Returns `true` if a block was passed to the calling method.
-#
-#     #caller
-# :       Returns the current execution stack as an array of strings.
-#
-#     #caller_locations
-# :       Returns the current execution stack as an array of
-#         Thread::Backtrace::Location objects.
-#
-#     #class
-# :       Returns the class of `self`.
-#
-#     #frozen?
-# :       Returns whether `self` is frozen.
-#
-#     #global_variables
-# :       Returns an array of global variables as symbols.
-#
-#     #local_variables
-# :       Returns an array of local variables as symbols.
-#
-#     #test
-# :       Performs specified tests on the given single file or pair of files.
-#
-#
+# *   #__callee__: Returns the called name of the current method as a symbol.
+# *   #__dir__: Returns the path to the directory from which the current method
+#     is called.
+# *   #__method__: Returns the name of the current method as a symbol.
+# *   #autoload?: Returns the file to be loaded when the given module is
+#     referenced.
+# *   #binding: Returns a Binding for the context at the point of call.
+# *   #block_given?: Returns `true` if a block was passed to the calling method.
+# *   #caller: Returns the current execution stack as an array of strings.
+# *   #caller_locations: Returns the current execution stack as an array of
+#     Thread::Backtrace::Location objects.
+# *   #class: Returns the class of `self`.
+# *   #frozen?: Returns whether `self` is frozen.
+# *   #global_variables: Returns an array of global variables as symbols.
+# *   #local_variables: Returns an array of local variables as symbols.
+# *   #test: Performs specified tests on the given single file or pair of files.
 #
 # ### Exiting
 #
-#     #abort
-# :       Exits the current process after printing the given arguments.
-#
-#     #at_exit
-# :       Executes the given block when the process exits.
-#
-#     #exit
-# :       Exits the current process after calling any registered `at_exit`
-#         handlers.
-#
-#     #exit!
-# :       Exits the current process without calling any registered `at_exit`
-#         handlers.
-#
-#
+# *   #abort: Exits the current process after printing the given arguments.
+# *   #at_exit: Executes the given block when the process exits.
+# *   #exit: Exits the current process after calling any registered `at_exit`
+#     handlers.
+# *   #exit!: Exits the current process without calling any registered `at_exit`
+#     handlers.
 #
 # ### Exceptions
 #
-#     #catch
-# :       Executes the given block, possibly catching a thrown object.
-#
-#     #raise (aliased as #fail)
-# :       Raises an exception based on the given arguments.
-#
-#     #throw
-# :       Returns from the active catch block waiting for the given tag.
-#
-#
+# *   #catch: Executes the given block, possibly catching a thrown object.
+# *   #raise (aliased as #fail): Raises an exception based on the given
+#     arguments.
+# *   #throw: Returns from the active catch block waiting for the given tag.
 #
 # ### IO
 #
-#     #gets
-# :       Returns and assigns to `$_` the next line from the current input.
-#
-#     #open
-# :       Creates an IO object connected to the given stream, file, or
-#         subprocess.
-#
-#     #p
-# :       Prints the given objects' inspect output to the standard output.
-#
-#     #pp
-# :       Prints the given objects in pretty form.
-#
-#     #print
-# :       Prints the given objects to standard output without a newline.
-#
-#     #printf
-# :       Prints the string resulting from applying the given format string to
-#         any additional arguments.
-#
-#     #putc
-# :       Equivalent to <tt.$stdout.putc(object)</tt> for the given object.
-#
-#     #puts
-# :       Equivalent to `$stdout.puts(*objects)` for the given objects.
-#
-#     #readline
-# :       Similar to #gets, but raises an exception at the end of file.
-#
-#     #readlines
-# :       Returns an array of the remaining lines from the current input.
-#
-#     #select
-# :       Same as IO.select.
-#
-#
+# *   ::pp: Prints the given objects in pretty form.
+# *   #gets: Returns and assigns to `$_` the next line from the current input.
+# *   #open: Creates an IO object connected to the given stream, file, or
+#     subprocess.
+# *   #p:  Prints the given objects' inspect output to the standard output.
+# *   #print: Prints the given objects to standard output without a newline.
+# *   #printf: Prints the string resulting from applying the given format string
+#     to any additional arguments.
+# *   #putc: Equivalent to <tt.$stdout.putc(object)</tt> for the given object.
+# *   #puts: Equivalent to `$stdout.puts(*objects)` for the given objects.
+# *   #readline: Similar to #gets, but raises an exception at the end of file.
+# *   #readlines: Returns an array of the remaining lines from the current
+#     input.
+# *   #select: Same as IO.select.
 #
 # ### Procs
 #
-#     #lambda
-# :       Returns a lambda proc for the given block.
-#
-#     #proc
-# :       Returns a new Proc; equivalent to Proc.new.
-#
-#
+# *   #lambda: Returns a lambda proc for the given block.
+# *   #proc: Returns a new Proc; equivalent to Proc.new.
 #
 # ### Tracing
 #
-#     #set_trace_func
-# :       Sets the given proc as the handler for tracing, or disables tracing if
-#         given `nil`.
-#
-#     #trace_var
-# :       Starts tracing assignments to the given global variable.
-#
-#     #untrace_var
-# :       Disables tracing of assignments to the given global variable.
-#
-#
+# *   #set_trace_func: Sets the given proc as the handler for tracing, or
+#     disables tracing if given `nil`.
+# *   #trace_var: Starts tracing assignments to the given global variable.
+# *   #untrace_var: Disables tracing of assignments to the given global
+#     variable.
 #
 # ### Subprocesses
 #
-#     #`cmd`
-# :       Returns the standard output of running `cmd` in a subshell.
-#
-#     #exec
-# :       Replaces current process with a new process.
-#
-#     #fork
-# :       Forks the current process into two processes.
-#
-#     #spawn
-# :       Executes the given command and returns its pid without waiting for
-#         completion.
-#
-#     #system
-# :       Executes the given command in a subshell.
-#
-#
+# *   [\`command`](rdoc-ref:Kernel#`): Returns the standard output of running
+#     `command` in a subshell.
+# *   #exec: Replaces current process with a new process.
+# *   #fork: Forks the current process into two processes.
+# *   #spawn: Executes the given command and returns its pid without waiting for
+#     completion.
+# *   #system: Executes the given command in a subshell.
 #
 # ### Loading
 #
-#     #autoload
-# :       Registers the given file to be loaded when the given constant is first
-#         referenced.
-#
-#     #load
-# :       Loads the given Ruby file.
-#
-#     #require
-# :       Loads the given Ruby file unless it has already been loaded.
-#
-#     #require_relative
-# :       Loads the Ruby file path relative to the calling file, unless it has
-#         already been loaded.
-#
-#
+# *   #autoload: Registers the given file to be loaded when the given constant
+#     is first referenced.
+# *   #load: Loads the given Ruby file.
+# *   #require: Loads the given Ruby file unless it has already been loaded.
+# *   #require_relative: Loads the Ruby file path relative to the calling file,
+#     unless it has already been loaded.
 #
 # ### Yielding
 #
-#     #tap
-# :       Yields `self` to the given block; returns `self`.
-#
-#     #then (aliased as #yield_self)
-# :       Yields `self` to the block and returns the result of the block.
-#
-#
+# *   #tap: Yields `self` to the given block; returns `self`.
+# *   #then (aliased as #yield_self): Yields `self` to the block and returns the
+#     result of the block.
 #
 # ### Random Values
 #
-#     #rand
-# :       Returns a pseudo-random floating point number strictly between 0.0 and
-#         1.0.
-#
-#     #srand
-# :       Seeds the pseudo-random number generator with the given number.
-#
-#
+# *   #rand: Returns a pseudo-random floating point number strictly between 0.0
+#     and 1.0.
+# *   #srand: Seeds the pseudo-random number generator with the given number.
 #
 # ### Other
 #
-#     #eval
-# :       Evaluates the given string as Ruby code.
-#
-#     #loop
-# :       Repeatedly executes the given block.
-#
-#     #sleep
-# :       Suspends the current thread for the given number of seconds.
-#
-#     #sprintf (aliased as #format)
-# :       Returns the string resulting from applying the given format string to
-#         any additional arguments.
-#
-#     #syscall
-# :       Runs an operating system call.
-#
-#     #trap
-# :       Specifies the handling of system signals.
-#
-#     #warn
-# :       Issue a warning based on the given messages and options.
+# *   #eval: Evaluates the given string as Ruby code.
+# *   #loop: Repeatedly executes the given block.
+# *   #sleep: Suspends the current thread for the given number of seconds.
+# *   #sprintf (aliased as #format): Returns the string resulting from applying
+#     the given format string to any additional arguments.
+# *   #syscall: Runs an operating system call.
+# *   #trap: Specifies the handling of system signals.
+# *   #warn: Issue a warning based on the given messages and options.
 #
 %a{annotate:rdoc:source:from=object.c}
 module Kernel : BasicObject
@@ -401,7 +270,7 @@ module Kernel : BasicObject
   #     1.class      #=> Integer
   #     self.class   #=> Object
   #
-  def class: () -> untyped
+  def class: () -> Class
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -419,7 +288,7 @@ module Kernel : BasicObject
   #     eval "str + ' Fred'"                      #=> "hello Fred"
   #     eval "str + ' Fred'", get_binding("bye")  #=> "bye Fred"
   #
-  def self?.eval: (String arg0, ?Binding arg1, ?String filename, ?Integer lineno) -> untyped
+  def self?.eval: (string src, ?Binding? scope, ?string filename, ?int lineno) -> untyped
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -477,106 +346,152 @@ module Kernel : BasicObject
   #     srand 1234               # => 1234
   #     [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
   #
-  def self?.srand: (?Numeric number) -> Numeric
+  def self?.srand: (?int number) -> Integer
 
   # <!--
   #   rdoc-file=process.c
-  #   - Kernel.fork  [{ block }]   -> integer or nil
-  #   - Process.fork [{ block }]   -> integer or nil
+  #   - Process.fork { ... } -> integer or nil
+  #   - Process.fork -> integer or nil
   # -->
-  # 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 the process ID of
-  # the child, and once in the child, returning *nil*. The child process can exit
-  # using Kernel.exit! to avoid running any `at_exit` functions. The parent
-  # process should use Process.wait to collect the termination statuses of its
-  # children or use Process.detach to register disinterest in their status;
-  # otherwise, the operating system may accumulate zombie processes.
+  # Creates a child process.
+  #
+  # With a block given, runs the block in the child process; on block exit, the
+  # child terminates with a status of zero:
+  #
+  #     puts "Before the fork: #{Process.pid}"
+  #     fork do
+  #       puts "In the child process: #{Process.pid}"
+  #     end                   # => 382141
+  #     puts "After the fork: #{Process.pid}"
+  #
+  # Output:
+  #
+  #     Before the fork: 420496
+  #     After the fork: 420496
+  #     In the child process: 420520
+  #
+  # With no block given, the `fork` call returns twice:
+  #
+  # *   Once in the parent process, returning the pid of the child process.
+  # *   Once in the child process, returning `nil`.
   #
-  # The thread calling fork is the only thread in the created child process. fork
-  # doesn't copy other threads.
+  # Example:
   #
-  # If fork is not usable, Process.respond_to?(:fork) returns false.
+  #     puts "This is the first line before the fork (pid #{Process.pid})"
+  #     puts fork
+  #     puts "This is the second line after the fork (pid #{Process.pid})"
   #
-  # Note that fork(2) is not available on some platforms like Windows and NetBSD
-  # 4. Therefore you should use spawn() instead of fork().
+  # Output:
+  #
+  #     This is the first line before the fork (pid 420199)
+  #     420223
+  #     This is the second line after the fork (pid 420199)
+  #
+  #     This is the second line after the fork (pid 420223)
+  #
+  # In either case, the child process may exit using Kernel.exit! to avoid the
+  # call to Kernel#at_exit.
+  #
+  # To avoid zombie processes, the parent process should call either:
+  #
+  # *   Process.wait, to collect the termination statuses of its children.
+  # *   Process.detach, to register disinterest in their status.
+  #
+  # The thread calling `fork` is the only thread in the created child process;
+  # `fork` doesn't copy other threads.
+  #
+  # Note that method `fork` is available on some platforms, but not on others:
+  #
+  #     Process.respond_to?(:fork) # => true # Would be false on some.
+  #
+  # If not, you may use ::spawn instead of `fork`.
   #
   def self?.fork: () -> Integer?
-                | () { () -> untyped } -> Integer?
-
-  def initialize_copy: (self object) -> self
+                | () { () -> void } -> Integer
 
   # <!--
   #   rdoc-file=object.c
-  #   - Array(arg)    -> array
+  #   - Array(object) -> object or new_array
   # -->
-  # Returns `arg` as an Array.
+  # Returns an array converted from `object`.
+  #
+  # Tries to convert `object` to an array using `to_ary` first and `to_a` second:
   #
-  # First tries to call `to_ary` on `arg`, then `to_a`. If `arg` does not respond
-  # to `to_ary` or `to_a`, returns an Array of length 1 containing `arg`.
+  #     Array([0, 1, 2])        # => [0, 1, 2]
+  #     Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]]
+  #     Array(0..4)             # => [0, 1, 2, 3, 4]
   #
-  # If `to_ary` or `to_a` returns something other than an Array, raises a
-  # TypeError.
+  # Returns `object` in an array, `[object]`, if `object` cannot be converted:
   #
-  #     Array(["a", "b"])  #=> ["a", "b"]
-  #     Array(1..5)        #=> [1, 2, 3, 4, 5]
-  #     Array(key: :value) #=> [[:key, :value]]
-  #     Array(nil)         #=> []
-  #     Array(1)           #=> [1]
+  #     Array(:foo)             # => [:foo]
   #
-  def self?.Array: (NilClass x) -> [ ]
-                 | [T] (::Array[T] x) -> ::Array[T]
-                 | [T] (::Range[T] x) -> ::Array[T]
-                 | [T] (_Each[T] x) -> ::Array[T]
-                 | [K, V] (::Hash[K, V] x) -> ::Array[[ K, V ]]
-                 | [T] (T x) -> ::Array[T]
+  def self?.Array: (nil) -> []
+                 | [T] (array[T] | _ToA[T] array_like) -> Array[T]
+                 | [T] (T ele) -> [T]
 
   # <!--
   #   rdoc-file=complex.c
-  #   - Complex(x[, y], exception: true)  ->  numeric or nil
+  #   - Complex(real, imag = 0, exception: true) -> complex or nil
+  #   - Complex(s, exception: true) -> complex or nil
   # -->
-  # Returns x+i*y;
+  # Returns a new Complex object if the arguments are valid; otherwise raises an
+  # exception if `exception` is `true`; otherwise returns `nil`.
   #
-  #     Complex(1, 2)    #=> (1+2i)
-  #     Complex('1+2i')  #=> (1+2i)
-  #     Complex(nil)     #=> TypeError
-  #     Complex(1, nil)  #=> TypeError
+  # With Numeric arguments `real` and `imag`, returns `Complex.rect(real, imag)`
+  # if the arguments are valid.
   #
-  #     Complex(1, nil, exception: false)  #=> nil
-  #     Complex('1+2', exception: false)   #=> nil
+  # With string argument `s`, returns a new Complex object if the argument is
+  # valid; the string may have:
   #
-  # Syntax of string form:
+  # *   One or two numeric substrings, each of which specifies a Complex, Float,
+  #     Integer, Numeric, or Rational value, specifying [rectangular
+  #     coordinates](rdoc-ref:Complex@Rectangular+Coordinates):
   #
-  #     string form = extra spaces , complex , extra spaces ;
-  #     complex = real part | [ sign ] , imaginary part
-  #             | real part , sign , imaginary part
-  #             | rational , "@" , rational ;
-  #     real part = rational ;
-  #     imaginary part = imaginary unit | unsigned rational , imaginary unit ;
-  #     rational = [ sign ] , unsigned rational ;
-  #     unsigned rational = numerator | numerator , "/" , denominator ;
-  #     numerator = integer part | fractional part | integer part , fractional part ;
-  #     denominator = digits ;
-  #     integer part = digits ;
-  #     fractional part = "." , digits , [ ( "e" | "E" ) , [ sign ] , digits ] ;
-  #     imaginary unit = "i" | "I" | "j" | "J" ;
-  #     sign = "-" | "+" ;
-  #     digits = digit , { digit | "_" , digit };
-  #     digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
-  #     extra spaces = ? \s* ? ;
+  #     *   Sign-separated real and imaginary numeric substrings (with trailing
+  #         character `'i'`):
+  #
+  #             Complex('1+2i')  # => (1+2i)
+  #             Complex('+1+2i') # => (1+2i)
+  #             Complex('+1-2i') # => (1-2i)
+  #             Complex('-1+2i') # => (-1+2i)
+  #             Complex('-1-2i') # => (-1-2i)
+  #
+  #     *   Real-only numeric string (without trailing character `'i'`):
+  #
+  #             Complex('1')  # => (1+0i)
+  #             Complex('+1') # => (1+0i)
+  #             Complex('-1') # => (-1+0i)
   #
-  # See String#to_c.
+  #     *   Imaginary-only numeric string (with trailing character `'i'`):
   #
-  def self?.Complex: (Numeric | String x, ?Numeric | String y, ?exception: bool exception) -> Complex
+  #             Complex('1i')  # => (0+1i)
+  #             Complex('+1i') # => (0+1i)
+  #             Complex('-1i') # => (0-1i)
+  #
+  # *   At-sign separated real and imaginary rational substrings, each of which
+  #     specifies a Rational value, specifying [polar
+  #     coordinates](rdoc-ref:Complex@Polar+Coordinates):
+  #
+  #         Complex('1/2@3/4')   # => (0.36584443443691045+0.34081938001166706i)
+  #         Complex('+1/2@+3/4') # => (0.36584443443691045+0.34081938001166706i)
+  #         Complex('+1/2@-3/4') # => (0.36584443443691045-0.34081938001166706i)
+  #         Complex('-1/2@+3/4') # => (-0.36584443443691045-0.34081938001166706i)
+  #         Complex('-1/2@-3/4') # => (-0.36584443443691045+0.34081938001166706i)
+  #
+  def self?.Complex: (_ToC complex_like, ?exception: true) -> Complex
+                   | (_ToC complex_like, exception: bool) -> Complex?
+                   | (Numeric | String real, ?Numeric | String imag, ?exception: true) -> Complex
+                   | (Numeric | String real, ?Numeric | String imag, exception: bool) -> Complex?
+                   | (untyped, ?untyped, ?exception: bool) -> Complex?
 
   # <!--
   #   rdoc-file=kernel.rb
   #   - Float(arg, exception: true)    -> float or nil
   # -->
   # Returns *arg* converted to a float. Numeric types are converted directly, and
-  # with exception to String and `nil` the rest are converted using *arg*`.to_f`.
-  # Converting a String with invalid characters will result in a ArgumentError.
-  # Converting `nil` generates a TypeError.  Exceptions can be suppressed by
+  # with exception to String and `nil`, the rest are converted using *arg*`.to_f`.
+  # Converting a String with invalid characters will result in an ArgumentError.
+  # Converting `nil` generates a TypeError. Exceptions can be suppressed by
   # passing `exception: false`.
   #
   #     Float(1)                 #=> 1.0
@@ -585,53 +500,121 @@ module Kernel : BasicObject
   #     Float(nil)               #=> TypeError: can't convert nil into Float
   #     Float("123.0_badstring", exception: false)  #=> nil
   #
-  def self?.Float: (Numeric | String x, ?exception: bool exception) -> Float
+  def self?.Float: (_ToF float_like, ?exception: true) -> Float
+                 | (_ToF float_like, exception: bool) -> Float?
+                 | (untyped, ?exception: bool) -> Float?
 
   # <!--
   #   rdoc-file=object.c
-  #   - Hash(arg)    -> hash
+  #   - Hash(object) -> object or new_hash
   # -->
-  # Converts *arg* to a Hash by calling *arg*`.to_hash`. Returns an empty Hash
-  # when *arg* is `nil` or `[]`.
+  # Returns a hash converted from `object`.
+  #
+  # *   If `object` is:
+  #
+  #     *   A hash, returns `object`.
+  #     *   An empty array or `nil`, returns an empty hash.
+  #
+  # *   Otherwise, if `object.to_hash` returns a hash, returns that hash.
+  # *   Otherwise, returns TypeError.
+  #
+  # Examples:
   #
-  #     Hash([])          #=> {}
-  #     Hash(nil)         #=> {}
-  #     Hash(key: :value) #=> {:key => :value}
-  #     Hash([1, 2, 3])   #=> TypeError
+  #     Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1}
+  #     Hash(nil)              # => {}
+  #     Hash([])               # => {}
   #
-  def self?.Hash: [K, V] (Object x) -> ::Hash[K, V]
+  def self?.Hash: [K, V] (nil | [] _empty) -> Hash[K, V]
+                | [K, V] (hash[K, V] hash_like) -> Hash[K, V]
 
   # <!--
-  #   rdoc-file=object.c
-  #   - Integer(arg, base=0, exception: true)    -> integer or nil
+  #   rdoc-file=kernel.rb
+  #   - Integer(object, base = 0, exception: true) -> integer or nil
   # -->
-  # Converts *arg* to an Integer. Numeric types are converted directly (with
-  # floating point numbers being truncated).  *base* (0, or between 2 and 36) is a
-  # base for integer string representation.  If *arg* is a String, when *base* is
-  # omitted or equals zero, radix indicators (`0`, `0b`, and `0x`) are honored. In
-  # any case, strings should consist only of one or more digits, except for that a
-  # sign, one underscore between two digits, and leading/trailing spaces are
-  # optional.  This behavior is different from that of String#to_i.  Non string
-  # values will be converted by first trying `to_int`, then `to_i`.
+  # Returns an integer converted from `object`.
+  #
+  # Tries to convert `object` to an integer using `to_int` first and `to_i`
+  # second; see below for exceptions.
+  #
+  # With a non-zero `base`, `object` must be a string or convertible to a string.
+  #
+  # #### Numeric objects
+  #
+  # With an integer argument `object` given, returns `object`:
+  #
+  #     Integer(1)                # => 1
+  #     Integer(-1)               # => -1
+  #
+  # With a floating-point argument `object` given, returns `object` truncated to
+  # an integer:
+  #
+  #     Integer(1.9)              # => 1  # Rounds toward zero.
+  #     Integer(-1.9)             # => -1 # Rounds toward zero.
+  #
+  # #### String objects
+  #
+  # With a string argument `object` and zero `base` given, returns `object`
+  # converted to an integer in base 10:
+  #
+  #     Integer('100')    # => 100
+  #     Integer('-100')   # => -100
+  #
+  # With `base` zero, string `object` may contain leading characters to specify
+  # the actual base (radix indicator):
+  #
+  #     Integer('0100')  # => 64  # Leading '0' specifies base 8.
+  #     Integer('0b100') # => 4   # Leading '0b' specifies base 2.
+  #     Integer('0x100') # => 256 # Leading '0x' specifies base 16.
+  #
+  # With a positive `base` (in range 2..36) given, returns `object` converted to
+  # an integer in the given base:
+  #
+  #     Integer('100', 2)   # => 4
+  #     Integer('100', 8)   # => 64
+  #     Integer('-100', 16) # => -256
   #
-  # Passing `nil` raises a TypeError, while passing a String that does not conform
-  # with numeric representation raises an ArgumentError. This behavior can be
-  # altered by passing `exception: false`, in this case a not convertible value
-  # will return `nil`.
+  # With a negative `base` (in range -36..-2) given, returns `object` converted to
+  # the radix indicator if it exists or `base`:
   #
-  #     Integer(123.999)    #=> 123
-  #     Integer("0x1a")     #=> 26
-  #     Integer(Time.new)   #=> 1204973019
-  #     Integer("0930", 10) #=> 930
-  #     Integer("111", 2)   #=> 7
-  #     Integer(" +1_0 ")   #=> 10
-  #     Integer(nil)        #=> TypeError: can't convert nil into Integer
-  #     Integer("x")        #=> ArgumentError: invalid value for Integer(): "x"
+  #     Integer('0x100', -2)   # => 256
+  #     Integer('100', -2)     # => 4
+  #     Integer('0b100', -8)   # => 4
+  #     Integer('100', -8)     # => 64
+  #     Integer('0o100', -10)  # => 64
+  #     Integer('100', -10)    # => 100
   #
-  #     Integer("x", exception: false)        #=> nil
+  # `base` -1 is equivalent to the -10 case.
   #
-  def self?.Integer: (Numeric | String arg, ?exception: bool exception) -> Integer
-                   | (String arg, ?Integer base, ?exception: bool exception) -> Integer
+  # When converting strings, surrounding whitespace and embedded underscores are
+  # allowed and ignored:
+  #
+  #     Integer(' 100 ')      # => 100
+  #     Integer('-1_0_0', 16) # => -256
+  #
+  # #### Other classes
+  #
+  # Examples with `object` of various other classes:
+  #
+  #     Integer(Rational(9, 10)) # => 0  # Rounds toward zero.
+  #     Integer(Complex(2, 0))   # => 2  # Imaginary part must be zero.
+  #     Integer(Time.now)        # => 1650974042
+  #
+  # #### Keywords
+  #
+  # With the optional keyword argument `exception` given as `true` (the default):
+  #
+  # *   Raises TypeError if `object` does not respond to `to_int` or `to_i`.
+  # *   Raises TypeError if `object` is `nil`.
+  # *   Raises ArgumentError if `object` is an invalid string.
+  #
+  # With `exception` given as `false`, an exception of any kind is suppressed and
+  # `nil` is returned.
+  #
+  def self?.Integer: (int | _ToI int_like, ?exception: true) -> Integer
+                   | (int | _ToI int_like, exception: bool) -> Integer?
+                   | (string str, int base, ?exception: true) -> Integer
+                   | (string str, int base, exception: bool) -> Integer?
+                   | (untyped, ?untyped, ?exception: bool) -> Integer?
 
   # <!--
   #   rdoc-file=rational.c
@@ -670,21 +653,33 @@ module Kernel : BasicObject
   #
   # See also String#to_r.
   #
-  def self?.Rational: (Numeric | String | Object x, ?Numeric | String y, ?exception: bool exception) -> Rational
+  def self?.Rational: (int | _ToR rational_like, ?exception: true) -> Rational
+                    | (int | _ToR rational_like, exception: bool) -> Rational?
+                    | (int | _ToR numer, ?int | _ToR denom, ?exception: true) -> Rational
+                    | (int | _ToR numer, ?int | _ToR denom, exception: bool) -> Rational?
+                    | [T] (Numeric & _RationalDiv[T] numer, Numeric denom, ?exception: bool) -> T
+                    | [T < Numeric] (T value, 1, ?exception: bool) -> T
+                    | (untyped, ?untyped, ?exception: bool) -> Rational?
+
+  interface _RationalDiv[T]
+    def /: (Numeric) -> T
+  end
 
   # <!--
   #   rdoc-file=object.c
-  #   - String(arg)   -> string
+  #   - String(object) -> object or new_string
   # -->
-  # Returns *arg* as a String.
+  # Returns a string converted from `object`.
+  #
+  # Tries to convert `object` to a string using `to_str` first and `to_s` second:
   #
-  # First tries to call its `to_str` method, then its `to_s` method.
+  #     String([0, 1, 2])        # => "[0, 1, 2]"
+  #     String(0..5)             # => "0..5"
+  #     String({foo: 0, bar: 1}) # => "{foo: 0, bar: 1}"
   #
-  #     String(self)        #=> "main"
-  #     String(self.class)  #=> "Object"
-  #     String(123456)      #=> "123456"
+  # Raises `TypeError` if `object` cannot be converted to a string.
   #
-  def self?.String: (_ToStr | _ToS x) -> String
+  def self?.String: (string | _ToS string_like) -> String
 
   # <!--
   #   rdoc-file=eval.c
@@ -717,28 +712,37 @@ module Kernel : BasicObject
 
   # <!--
   #   rdoc-file=io.c
-  #   - `cmd`    -> string
+  #   - `command` -> string
   # -->
-  # Returns the standard output of running *cmd* in a subshell. The built-in
-  # syntax `%x{...}` uses this method. Sets `$?` to the process status.
+  # Returns the `$stdout` output from running `command` in a subshell; sets global
+  # variable `$?` to the process status.
+  #
+  # This method has potential security vulnerabilities if called with untrusted
+  # input; see [Command Injection](rdoc-ref:command_injection.rdoc).
+  #
+  # Examples:
+  #
+  #     $ `date`                 # => "Wed Apr  9 08:56:30 CDT 2003\n"
+  #     $ `echo oops && exit 99` # => "oops\n"
+  #     $ $?                     # => #<Process::Status: pid 17088 exit 99>
+  #     $ $?.status              # => 99>
   #
-  #     `date`                   #=> "Wed Apr  9 08:56:30 CDT 2003\n"
-  #     `ls testdir`.split[1]    #=> "main.rb"
-  #     `echo oops && exit 99`   #=> "oops\n"
-  #     $?.exitstatus            #=> 99
+  # The built-in syntax `%x{...}` uses this method.
   #
   def self?.`: (String arg0) -> String
 
   # <!--
   #   rdoc-file=process.c
   #   - abort
-  #   - Kernel::abort([msg])
-  #   - Process.abort([msg])
+  #   - Process.abort(msg = nil)
   # -->
-  # Terminate execution immediately, effectively by calling `Kernel.exit(false)`.
-  # If *msg* is given, it is written to STDERR prior to terminating.
+  # Terminates execution immediately, effectively by calling `Kernel.exit(false)`.
   #
-  def self?.abort: (?String msg) -> bot
+  # If string argument `msg` is given, it is written to STDERR prior to
+  # termination; otherwise, if an exception was raised, prints its message and
+  # backtrace.
+  #
+  def self?.abort: (?string msg) -> bot
 
   # <!--
   #   rdoc-file=eval_jump.c
@@ -759,658 +763,371 @@ module Kernel : BasicObject
   #
   #     goodbye cruel world
   #
-  def self?.at_exit: () { () -> untyped } -> Proc
+  def self?.at_exit: () { () -> void } -> Proc
 
   # <!--
   #   rdoc-file=load.c
-  #   - autoload(module, filename)   -> nil
+  #   - autoload(const, filename)   -> nil
   # -->
   # Registers *filename* to be loaded (using Kernel::require) the first time that
-  # *module* (which may be a String or a symbol) is accessed.
+  # *const* (which may be a String or a symbol) is accessed.
   #
   #     autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
   #
-  def self?.autoload: (String | Symbol _module, String filename) -> NilClass
+  # If *const* is defined as autoload, the file name to be loaded is replaced with
+  # *filename*.  If *const* is defined but not as autoload, does nothing.
+  #
+  def self?.autoload: (interned _module, String filename) -> NilClass
 
   # <!--
   #   rdoc-file=load.c
   #   - autoload?(name, inherit=true)   -> String or nil
   # -->
-  # Returns *filename* to be loaded if *name* is registered as `autoload`.
+  # Returns *filename* to be loaded if *name* is registered as `autoload` in the
+  # current namespace or one of its ancestors.
   #
   #     autoload(:B, "b")
   #     autoload?(:B)            #=> "b"
   #
-  def self?.autoload?: (Symbol | String name) -> String?
+  #     module C
+  #       autoload(:D, "d")
+  #       autoload?(:D)          #=> "d"
+  #       autoload?(:B)          #=> nil
+  #     end
+  #
+  #     class E
+  #       autoload(:F, "f")
+  #       autoload?(:F)          #=> "f"
+  #       autoload?(:B)          #=> "b"
+  #     end
+  #
+  def self?.autoload?: (interned name) -> String?
 
   # <!--
   #   rdoc-file=proc.c
   #   - binding -> a_binding
   # -->
-  # Returns a `Binding` object, describing the variable and method bindings at the
-  # point of call. This object can be used when calling `eval` to execute the
-  # evaluated command in this environment. See also the description of class
-  # `Binding`.
+  # Returns a Binding object, describing the variable and method bindings at the
+  # point of call. This object can be used when calling Binding#eval to execute
+  # the evaluated command in this environment, or extracting its local variables.
+  #
+  #     class User
+  #       def initialize(name, position)
+  #         @name = name
+  #         @position = position
+  #       end
+  #
+  #       def get_binding
+  #         binding
+  #       end
+  #     end
+  #
+  #     user = User.new('Joan', 'manager')
+  #     template = '{name: @name, position: @position}'
+  #
+  #     # evaluate template in context of the object
+  #     eval(template, user.get_binding)
+  #     #=> {:name=>"Joan", :position=>"manager"}
   #
-  #     def get_binding(param)
-  #       binding
+  # Binding#local_variable_get can be used to access the variables whose names are
+  # reserved Ruby keywords:
+  #
+  #     # This is valid parameter declaration, but `if` parameter can't
+  #     # be accessed by name, because it is a reserved word.
+  #     def validate(field, validation, if: nil)
+  #       condition = binding.local_variable_get('if')
+  #       return unless condition
+  #
+  #       # ...Some implementation ...
   #     end
-  #     b = get_binding("hello")
-  #     eval("param", b)   #=> "hello"
+  #
+  #     validate(:name, :empty?, if: false) # skips validation
+  #     validate(:name, :empty?, if: true) # performs validation
   #
   def self?.binding: () -> Binding
 
   # <!--
   #   rdoc-file=process.c
-  #   - exit(status=true)
-  #   - Kernel::exit(status=true)
-  #   - Process::exit(status=true)
+  #   - exit(status = true)
+  #   - Process.exit(status = true)
   # -->
-  # Initiates the termination of the Ruby script by raising the SystemExit
-  # exception. This exception may be caught. The optional parameter is used to
-  # return a status code to the invoking environment. `true` and `FALSE` of
-  # *status* means success and failure respectively.  The interpretation of other
-  # integer values are system dependent.
+  # Initiates termination of the Ruby script by raising SystemExit; the exception
+  # may be caught. Returns exit status `status` to the underlying operating
+  # system.
+  #
+  # Values `true` and `false` for argument `status` indicate, respectively,
+  # success and failure; The meanings of integer values are system-dependent.
+  #
+  # Example:
   #
   #     begin
   #       exit
-  #       puts "never get here"
+  #       puts 'Never get here.'
   #     rescue SystemExit
-  #       puts "rescued a SystemExit exception"
+  #       puts 'Rescued a SystemExit exception.'
   #     end
-  #     puts "after begin block"
+  #     puts 'After begin block.'
   #
-  # *produces:*
+  # Output:
   #
-  #     rescued a SystemExit exception
-  #     after begin block
+  #     Rescued a SystemExit exception.
+  #     After begin block.
   #
-  # Just prior to termination, Ruby executes any `at_exit` functions (see
-  # Kernel::at_exit) and runs any object finalizers (see
+  # Just prior to final termination, Ruby executes any at-exit procedures (see
+  # Kernel::at_exit) and any object finalizers (see
   # ObjectSpace::define_finalizer).
   #
-  #     at_exit { puts "at_exit function" }
-  #     ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
+  # Example:
+  #
+  #     at_exit { puts 'In at_exit function.' }
+  #     ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' })
   #     exit
   #
-  # *produces:*
+  # Output:
   #
-  #     at_exit function
-  #     in finalizer
+  #     In at_exit function.
+  #     In finalizer.
   #
-  def self?.exit: () -> bot
-                | (?Integer | TrueClass | FalseClass status) -> bot
+  def self?.exit: (?int | bool status) -> bot
 
   # <!--
   #   rdoc-file=process.c
-  #   - Process.exit!(status=false)
+  #   - exit!(status = false)
+  #   - Process.exit!(status = false)
   # -->
-  # Exits the process immediately. No exit handlers are run. *status* is returned
-  # to the underlying system as the exit status.
+  # Exits the process immediately; no exit handlers are called. Returns exit
+  # status `status` to the underlying operating system.
   #
   #     Process.exit!(true)
   #
-  def self?.exit!: (Integer | TrueClass | FalseClass status) -> bot
+  # Values `true` and `false` for argument `status` indicate, respectively,
+  # success and failure; The meanings of integer values are system-dependent.
+  #
+  def self?.exit!: (?int | bool status) -> bot
 
   # <!-- rdoc-file=eval.c -->
-  # With no arguments, raises the exception in `$!` or raises a RuntimeError if
-  # `$!` is `nil`.  With a single `String` argument, raises a `RuntimeError` with
-  # the string as a message. Otherwise, the first parameter should be an
-  # `Exception` class (or another object that returns an `Exception` object when
-  # sent an `exception` message).  The optional second parameter sets the message
-  # associated with the exception (accessible via Exception#message), and the
-  # third parameter is an array of callback information (accessible via
-  # Exception#backtrace). The `cause` of the generated exception (accessible via
-  # Exception#cause) is automatically set to the "current" exception (`$!`), if
-  # any. An alternative value, either an `Exception` object or `nil`, can be
-  # specified via the `:cause` argument.
-  #
-  # Exceptions are caught by the `rescue` clause of `begin...end` blocks.
-  #
-  #     raise "Failed to create socket"
-  #     raise ArgumentError, "No parameters", caller
+  # Raises an exception; see [Exceptions](rdoc-ref:exceptions.md).
+  #
+  # Argument `exception` sets the class of the new exception; it should be class
+  # Exception or one of its subclasses (most commonly, RuntimeError or
+  # StandardError), or an instance of one of those classes:
+  #
+  #     begin
+  #       raise(StandardError)
+  #     rescue => x
+  #       p x.class
+  #     end
+  #     # => StandardError
+  #
+  # Argument `message` sets the stored message in the new exception, which may be
+  # retrieved by method Exception#message; the message must be a
+  # [string-convertible
+  # object](rdoc-ref:implicit_conversion.rdoc@String-Convertible+Objects) or
+  # `nil`:
+  #
+  #     begin
+  #       raise(StandardError, 'Boom')
+  #     rescue => x
+  #       p x.message
+  #     end
+  #     # => "Boom"
+  #
+  # If argument `message` is not given, the message is the exception class name.
+  #
+  # See [Messages](rdoc-ref:exceptions.md@Messages).
+  #
+  # Argument `backtrace` might be used to modify the backtrace of the new
+  # exception, as reported by Exception#backtrace and
+  # Exception#backtrace_locations; the backtrace must be an array of
+  # Thread::Backtrace::Location, an array of strings, a single string, or `nil`.
+  #
+  # Using the array of Thread::Backtrace::Location instances is the most
+  # consistent option and should be preferred when possible. The necessary value
+  # might be obtained from #caller_locations, or copied from
+  # Exception#backtrace_locations of another error:
+  #
+  #     begin
+  #       do_some_work()
+  #     rescue ZeroDivisionError => ex
+  #       raise(LogicalError, "You have an error in your math", ex.backtrace_locations)
+  #     end
+  #
+  # The ways, both Exception#backtrace and Exception#backtrace_locations of the
+  # raised error are set to the same backtrace.
+  #
+  # When the desired stack of locations is not available and should be constructed
+  # from scratch, an array of strings or a singular string can be used. In this
+  # case, only Exception#backtrace is set:
+  #
+  #     begin
+  #       raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1])
+  #     rescue => ex
+  #       p ex.backtrace
+  #       # => ["dsl.rb:3", "framework.rb:1"]
+  #       p ex.backtrace_locations
+  #       # => nil
+  #     end
+  #
+  # If argument `backtrace` is not given, the backtrace is set according to an
+  # array of Thread::Backtrace::Location objects, as derived from the call stack.
+  #
+  # See [Backtraces](rdoc-ref:exceptions.md@Backtraces).
+  #
+  # Keyword argument `cause` sets the stored cause in the new exception, which may
+  # be retrieved by method Exception#cause; the cause must be an exception object
+  # (Exception or one of its subclasses), or `nil`:
+  #
+  #     begin
+  #       raise(StandardError, cause: RuntimeError.new)
+  #     rescue => x
+  #       p x.cause
+  #     end
+  #     # => #<RuntimeError: RuntimeError>
+  #
+  # If keyword argument `cause` is not given, the cause is the value of `$!`.
+  #
+  # See [Cause](rdoc-ref:exceptions.md@Cause).
+  #
+  # In the alternate calling sequence, where argument `exception` *not* given,
+  # raises a new exception of the class given by `$!`, or of class RuntimeError if
+  # `$!` is `nil`:
+  #
+  #     begin
+  #       raise
+  #     rescue => x
+  #       p x
+  #     end
+  #     # => RuntimeError
+  #
+  # With argument `exception` not given, argument `message` and keyword argument
+  # `cause` may be given, but argument `backtrace` may not be given.
   #
   def self?.fail: () -> bot
-                | (String message, ?cause: Exception?) -> bot
-                | (_Exception exception, ?untyped message, ?::Array[String] backtrace, ?cause: Exception?) -> bot
+                | (string message, ?cause: Exception?) -> bot
+                | (_Exception exception, ?_ToS? message, ?String | Array[String] | Array[Thread::Backtrace::Location] | nil backtrace, ?cause: Exception?) -> bot
+                | (_Exception exception, ?cause: Exception?, **untyped) -> bot
 
   # <!--
   #   rdoc-file=eval.c
-  #   - raise
-  #   - raise(string, cause: $!)
-  #   - raise(exception [, string [, array]], cause: $!)
-  #   - fail
-  #   - fail(string, cause: $!)
-  #   - fail(exception [, string [, array]], cause: $!)
-  # -->
-  # With no arguments, raises the exception in `$!` or raises a RuntimeError if
-  # `$!` is `nil`.  With a single `String` argument, raises a `RuntimeError` with
-  # the string as a message. Otherwise, the first parameter should be an
-  # `Exception` class (or another object that returns an `Exception` object when
-  # sent an `exception` message).  The optional second parameter sets the message
-  # associated with the exception (accessible via Exception#message), and the
-  # third parameter is an array of callback information (accessible via
-  # Exception#backtrace). The `cause` of the generated exception (accessible via
-  # Exception#cause) is automatically set to the "current" exception (`$!`), if
-  # any. An alternative value, either an `Exception` object or `nil`, can be
-  # specified via the `:cause` argument.
-  #
-  # Exceptions are caught by the `rescue` clause of `begin...end` blocks.
-  #
-  #     raise "Failed to create socket"
-  #     raise ArgumentError, "No parameters", caller
+  #   - raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
+  #   - raise(message = nil, cause: $!)
+  # -->
+  # Raises an exception; see [Exceptions](rdoc-ref:exceptions.md).
+  #
+  # Argument `exception` sets the class of the new exception; it should be class
+  # Exception or one of its subclasses (most commonly, RuntimeError or
+  # StandardError), or an instance of one of those classes:
+  #
+  #     begin
+  #       raise(StandardError)
+  #     rescue => x
+  #       p x.class
+  #     end
+  #     # => StandardError
+  #
+  # Argument `message` sets the stored message in the new exception, which may be
+  # retrieved by method Exception#message; the message must be a
+  # [string-convertible
+  # object](rdoc-ref:implicit_conversion.rdoc@String-Convertible+Objects) or
+  # `nil`:
+  #
+  #     begin
+  #       raise(StandardError, 'Boom')
+  #     rescue => x
+  #       p x.message
+  #     end
+  #     # => "Boom"
+  #
+  # If argument `message` is not given, the message is the exception class name.
+  #
+  # See [Messages](rdoc-ref:exceptions.md@Messages).
+  #
+  # Argument `backtrace` might be used to modify the backtrace of the new
+  # exception, as reported by Exception#backtrace and
+  # Exception#backtrace_locations; the backtrace must be an array of
+  # Thread::Backtrace::Location, an array of strings, a single string, or `nil`.
+  #
+  # Using the array of Thread::Backtrace::Location instances is the most
+  # consistent option and should be preferred when possible. The necessary value
+  # might be obtained from #caller_locations, or copied from
+  # Exception#backtrace_locations of another error:
+  #
+  #     begin
+  #       do_some_work()
+  #     rescue ZeroDivisionError => ex
+  #       raise(LogicalError, "You have an error in your math", ex.backtrace_locations)
+  #     end
+  #
+  # The ways, both Exception#backtrace and Exception#backtrace_locations of the
+  # raised error are set to the same backtrace.
+  #
+  # When the desired stack of locations is not available and should be constructed
+  # from scratch, an array of strings or a singular string can be used. In this
+  # case, only Exception#backtrace is set:
+  #
+  #     begin
+  #       raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1])
+  #     rescue => ex
+  #       p ex.backtrace
+  #       # => ["dsl.rb:3", "framework.rb:1"]
+  #       p ex.backtrace_locations
+  #       # => nil
+  #     end
+  #
+  # If argument `backtrace` is not given, the backtrace is set according to an
+  # array of Thread::Backtrace::Location objects, as derived from the call stack.
+  #
+  # See [Backtraces](rdoc-ref:exceptions.md@Backtraces).
+  #
+  # Keyword argument `cause` sets the stored cause in the new exception, which may
+  # be retrieved by method Exception#cause; the cause must be an exception object
+  # (Exception or one of its subclasses), or `nil`:
+  #
+  #     begin
+  #       raise(StandardError, cause: RuntimeError.new)
+  #     rescue => x
+  #       p x.cause
+  #     end
+  #     # => #<RuntimeError: RuntimeError>
+  #
+  # If keyword argument `cause` is not given, the cause is the value of `$!`.
+  #
+  # See [Cause](rdoc-ref:exceptions.md@Cause).
+  #
+  # In the alternate calling sequence, where argument `exception` *not* given,
+  # raises a new exception of the class given by `$!`, or of class RuntimeError if
+  # `$!` is `nil`:
+  #
+  #     begin
+  #       raise
+  #     rescue => x
+  #       p x
+  #     end
+  #     # => RuntimeError
+  #
+  # With argument `exception` not given, argument `message` and keyword argument
+  # `cause` may be given, but argument `backtrace` may not be given.
   #
   alias raise fail
 
   alias self.raise self.fail
 
   # <!-- rdoc-file=object.c -->
-  # Returns the string resulting from applying *format_string* to any additional
-  # arguments.  Within the format string, any characters other than format
-  # sequences are copied to the result.
-  #
-  # The syntax of a format sequence is as follows.
-  #
-  #     %[flags][width][.precision]type
-  #
-  # A format sequence consists of a percent sign, followed by optional flags,
-  # width, and precision indicators, then terminated with a field type character.
-  # The field type controls how the corresponding `sprintf` argument is to be
-  # interpreted, while the flags modify that interpretation.
-  #
-  # The field type characters are:
-  #
-  #     Field |  Integer Format
-  #     ------+--------------------------------------------------------------
-  #       b   | Convert argument as a binary number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..1'.
-  #       B   | Equivalent to `b', but uses an uppercase 0B for prefix
-  #           | in the alternative format by #.
-  #       d   | Convert argument as a decimal number.
-  #       i   | Identical to `d'.
-  #       o   | Convert argument as an octal number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..7'.
-  #       u   | Identical to `d'.
-  #       x   | Convert argument as a hexadecimal number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..f' (representing an infinite string of
-  #           | leading 'ff's).
-  #       X   | Equivalent to `x', but uses uppercase letters.
-  #
-  #     Field |  Float Format
-  #     ------+--------------------------------------------------------------
-  #       e   | Convert floating point argument into exponential notation
-  #           | with one digit before the decimal point as [-]d.dddddde[+-]dd.
-  #           | The precision specifies the number of digits after the decimal
-  #           | point (defaulting to six).
-  #       E   | Equivalent to `e', but uses an uppercase E to indicate
-  #           | the exponent.
-  #       f   | Convert floating point argument as [-]ddd.dddddd,
-  #           | where the precision specifies the number of digits after
-  #           | the decimal point.
-  #       g   | Convert a floating point number using exponential form
-  #           | if the exponent is less than -4 or greater than or
-  #           | equal to the precision, or in dd.dddd form otherwise.
-  #           | The precision specifies the number of significant digits.
-  #       G   | Equivalent to `g', but use an uppercase `E' in exponent form.
-  #       a   | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
-  #           | which is consisted from optional sign, "0x", fraction part
-  #           | as hexadecimal, "p", and exponential part as decimal.
-  #       A   | Equivalent to `a', but use uppercase `X' and `P'.
-  #
-  #     Field |  Other Format
-  #     ------+--------------------------------------------------------------
-  #       c   | Argument is the numeric code for a single character or
-  #           | a single character string itself.
-  #       p   | The valuing of argument.inspect.
-  #       s   | Argument is a string to be substituted.  If the format
-  #           | sequence contains a precision, at most that many characters
-  #           | will be copied.
-  #       %   | A percent sign itself will be displayed.  No argument taken.
-  #
-  # The flags modifies the behavior of the formats. The flag characters are:
-  #
-  #     Flag     | Applies to    | Meaning
-  #     ---------+---------------+-----------------------------------------
-  #     space    | bBdiouxX      | Leave a space at the start of
-  #              | aAeEfgG       | non-negative numbers.
-  #              | (numeric fmt) | For `o', `x', `X', `b' and `B', use
-  #              |               | a minus sign with absolute value for
-  #              |               | negative values.
-  #     ---------+---------------+-----------------------------------------
-  #     (digit)$ | all           | Specifies the absolute argument number
-  #              |               | for this field.  Absolute and relative
-  #              |               | argument numbers cannot be mixed in a
-  #              |               | sprintf string.
-  #     ---------+---------------+-----------------------------------------
-  #      #       | bBoxX         | Use an alternative format.
-  #              | aAeEfgG       | For the conversions `o', increase the precision
-  #              |               | until the first digit will be `0' if
-  #              |               | it is not formatted as complements.
-  #              |               | For the conversions `x', `X', `b' and `B'
-  #              |               | on non-zero, prefix the result with ``0x'',
-  #              |               | ``0X'', ``0b'' and ``0B'', respectively.
-  #              |               | For `a', `A', `e', `E', `f', `g', and 'G',
-  #              |               | force a decimal point to be added,
-  #              |               | even if no digits follow.
-  #              |               | For `g' and 'G', do not remove trailing zeros.
-  #     ---------+---------------+-----------------------------------------
-  #     +        | bBdiouxX      | Add a leading plus sign to non-negative
-  #              | aAeEfgG       | numbers.
-  #              | (numeric fmt) | For `o', `x', `X', `b' and `B', use
-  #              |               | a minus sign with absolute value for
-  #              |               | negative values.
-  #     ---------+---------------+-----------------------------------------
-  #     -        | all           | Left-justify the result of this conversion.
-  #     ---------+---------------+-----------------------------------------
-  #     0 (zero) | bBdiouxX      | Pad with zeros, not spaces.
-  #              | aAeEfgG       | For `o', `x', `X', `b' and `B', radix-1
-  #              | (numeric fmt) | is used for negative numbers formatted as
-  #              |               | complements.
-  #     ---------+---------------+-----------------------------------------
-  #     *        | all           | Use the next argument as the field width.
-  #              |               | If negative, left-justify the result. If the
-  #              |               | asterisk is followed by a number and a dollar
-  #              |               | sign, use the indicated argument as the width.
-  #
-  # Examples of flags:
-  #
-  #     # `+' and space flag specifies the sign of non-negative numbers.
-  #     sprintf("%d", 123)  #=> "123"
-  #     sprintf("%+d", 123) #=> "+123"
-  #     sprintf("% d", 123) #=> " 123"
-  #
-  #     # `#' flag for `o' increases number of digits to show `0'.
-  #     # `+' and space flag changes format of negative numbers.
-  #     sprintf("%o", 123)   #=> "173"
-  #     sprintf("%#o", 123)  #=> "0173"
-  #     sprintf("%+o", -123) #=> "-173"
-  #     sprintf("%o", -123)  #=> "..7605"
-  #     sprintf("%#o", -123) #=> "..7605"
-  #
-  #     # `#' flag for `x' add a prefix `0x' for non-zero numbers.
-  #     # `+' and space flag disables complements for negative numbers.
-  #     sprintf("%x", 123)   #=> "7b"
-  #     sprintf("%#x", 123)  #=> "0x7b"
-  #     sprintf("%+x", -123) #=> "-7b"
-  #     sprintf("%x", -123)  #=> "..f85"
-  #     sprintf("%#x", -123) #=> "0x..f85"
-  #     sprintf("%#x", 0)    #=> "0"
-  #
-  #     # `#' for `X' uses the prefix `0X'.
-  #     sprintf("%X", 123)  #=> "7B"
-  #     sprintf("%#X", 123) #=> "0X7B"
-  #
-  #     # `#' flag for `b' add a prefix `0b' for non-zero numbers.
-  #     # `+' and space flag disables complements for negative numbers.
-  #     sprintf("%b", 123)   #=> "1111011"
-  #     sprintf("%#b", 123)  #=> "0b1111011"
-  #     sprintf("%+b", -123) #=> "-1111011"
-  #     sprintf("%b", -123)  #=> "..10000101"
-  #     sprintf("%#b", -123) #=> "0b..10000101"
-  #     sprintf("%#b", 0)    #=> "0"
-  #
-  #     # `#' for `B' uses the prefix `0B'.
-  #     sprintf("%B", 123)  #=> "1111011"
-  #     sprintf("%#B", 123) #=> "0B1111011"
-  #
-  #     # `#' for `e' forces to show the decimal point.
-  #     sprintf("%.0e", 1)  #=> "1e+00"
-  #     sprintf("%#.0e", 1) #=> "1.e+00"
-  #
-  #     # `#' for `f' forces to show the decimal point.
-  #     sprintf("%.0f", 1234)  #=> "1234"
-  #     sprintf("%#.0f", 1234) #=> "1234."
-  #
-  #     # `#' for `g' forces to show the decimal point.
-  #     # It also disables stripping lowest zeros.
-  #     sprintf("%g", 123.4)   #=> "123.4"
-  #     sprintf("%#g", 123.4)  #=> "123.400"
-  #     sprintf("%g", 123456)  #=> "123456"
-  #     sprintf("%#g", 123456) #=> "123456."
-  #
-  # The field width is an optional integer, followed optionally by a period and a
-  # precision.  The width specifies the minimum number of characters that will be
-  # written to the result for this field.
-  #
-  # Examples of width:
-  #
-  #     # padding is done by spaces,       width=20
-  #     # 0 or radix-1.             <------------------>
-  #     sprintf("%20d", 123)   #=> "                 123"
-  #     sprintf("%+20d", 123)  #=> "                +123"
-  #     sprintf("%020d", 123)  #=> "00000000000000000123"
-  #     sprintf("%+020d", 123) #=> "+0000000000000000123"
-  #     sprintf("% 020d", 123) #=> " 0000000000000000123"
-  #     sprintf("%-20d", 123)  #=> "123                 "
-  #     sprintf("%-+20d", 123) #=> "+123                "
-  #     sprintf("%- 20d", 123) #=> " 123                "
-  #     sprintf("%020x", -123) #=> "..ffffffffffffffff85"
-  #
-  # For numeric fields, the precision controls the number of decimal places
-  # displayed.  For string fields, the precision determines the maximum number of
-  # characters to be copied from the string.  (Thus, the format sequence `%10.10s`
-  # will always contribute exactly ten characters to the result.)
-  #
-  # Examples of precisions:
-  #
-  #     # precision for `d', 'o', 'x' and 'b' is
-  #     # minimum number of digits               <------>
-  #     sprintf("%20.8d", 123)  #=> "            00000123"
-  #     sprintf("%20.8o", 123)  #=> "            00000173"
-  #     sprintf("%20.8x", 123)  #=> "            0000007b"
-  #     sprintf("%20.8b", 123)  #=> "            01111011"
-  #     sprintf("%20.8d", -123) #=> "           -00000123"
-  #     sprintf("%20.8o", -123) #=> "            ..777605"
-  #     sprintf("%20.8x", -123) #=> "            ..ffff85"
-  #     sprintf("%20.8b", -11)  #=> "            ..110101"
-  #
-  #     # "0x" and "0b" for `#x' and `#b' is not counted for
-  #     # precision but "0" for `#o' is counted.  <------>
-  #     sprintf("%#20.8d", 123)  #=> "            00000123"
-  #     sprintf("%#20.8o", 123)  #=> "            00000173"
-  #     sprintf("%#20.8x", 123)  #=> "          0x0000007b"
-  #     sprintf("%#20.8b", 123)  #=> "          0b01111011"
-  #     sprintf("%#20.8d", -123) #=> "           -00000123"
-  #     sprintf("%#20.8o", -123) #=> "            ..777605"
-  #     sprintf("%#20.8x", -123) #=> "          0x..ffff85"
-  #     sprintf("%#20.8b", -11)  #=> "          0b..110101"
-  #
-  #     # precision for `e' is number of
-  #     # digits after the decimal point           <------>
-  #     sprintf("%20.8e", 1234.56789) #=> "      1.23456789e+03"
-  #
-  #     # precision for `f' is number of
-  #     # digits after the decimal point               <------>
-  #     sprintf("%20.8f", 1234.56789) #=> "       1234.56789000"
-  #
-  #     # precision for `g' is number of
-  #     # significant digits                          <------->
-  #     sprintf("%20.8g", 1234.56789) #=> "           1234.5679"
-  #
-  #     #                                         <------->
-  #     sprintf("%20.8g", 123456789)  #=> "       1.2345679e+08"
-  #
-  #     # precision for `s' is
-  #     # maximum number of characters                    <------>
-  #     sprintf("%20.8s", "string test") #=> "            string t"
+  # Returns the string resulting from formatting `objects` into `format_string`.
   #
-  # Examples:
-  #
-  #     sprintf("%d %04x", 123, 123)               #=> "123 007b"
-  #     sprintf("%08b '%4s'", 123, 123)            #=> "01111011 ' 123'"
-  #     sprintf("%1$*2$s %2$d %1$s", "hello", 8)   #=> "   hello 8 hello"
-  #     sprintf("%1$*2$s %2$d", "hello", -8)       #=> "hello    -8"
-  #     sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23)   #=> "+1.23: 1.23:1.23"
-  #     sprintf("%u", -123)                        #=> "-123"
-  #
-  # For more complex formatting, Ruby supports a reference by name. %<name>s style
-  # uses format style, but %{name} style doesn't.
-  #
-  # Examples:
-  #     sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
-  #       #=> 1 : 2.000000
-  #     sprintf("%{foo}f", { :foo => 1 })
-  #       # => "1f"
+  # For details on `format_string`, see [Format
+  # Specifications](rdoc-ref:format_specifications.rdoc).
   #
   def self?.format: (String format, *untyped args) -> String
 
   # <!--
   #   rdoc-file=object.c
-  #   - format(format_string [, arguments...] )   -> string
-  #   - sprintf(format_string [, arguments...] )  -> string
-  # -->
-  # Returns the string resulting from applying *format_string* to any additional
-  # arguments.  Within the format string, any characters other than format
-  # sequences are copied to the result.
-  #
-  # The syntax of a format sequence is as follows.
-  #
-  #     %[flags][width][.precision]type
-  #
-  # A format sequence consists of a percent sign, followed by optional flags,
-  # width, and precision indicators, then terminated with a field type character.
-  # The field type controls how the corresponding `sprintf` argument is to be
-  # interpreted, while the flags modify that interpretation.
-  #
-  # The field type characters are:
-  #
-  #     Field |  Integer Format
-  #     ------+--------------------------------------------------------------
-  #       b   | Convert argument as a binary number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..1'.
-  #       B   | Equivalent to `b', but uses an uppercase 0B for prefix
-  #           | in the alternative format by #.
-  #       d   | Convert argument as a decimal number.
-  #       i   | Identical to `d'.
-  #       o   | Convert argument as an octal number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..7'.
-  #       u   | Identical to `d'.
-  #       x   | Convert argument as a hexadecimal number.
-  #           | Negative numbers will be displayed as a two's complement
-  #           | prefixed with `..f' (representing an infinite string of
-  #           | leading 'ff's).
-  #       X   | Equivalent to `x', but uses uppercase letters.
-  #
-  #     Field |  Float Format
-  #     ------+--------------------------------------------------------------
-  #       e   | Convert floating point argument into exponential notation
-  #           | with one digit before the decimal point as [-]d.dddddde[+-]dd.
-  #           | The precision specifies the number of digits after the decimal
-  #           | point (defaulting to six).
-  #       E   | Equivalent to `e', but uses an uppercase E to indicate
-  #           | the exponent.
-  #       f   | Convert floating point argument as [-]ddd.dddddd,
-  #           | where the precision specifies the number of digits after
-  #           | the decimal point.
-  #       g   | Convert a floating point number using exponential form
-  #           | if the exponent is less than -4 or greater than or
-  #           | equal to the precision, or in dd.dddd form otherwise.
-  #           | The precision specifies the number of significant digits.
-  #       G   | Equivalent to `g', but use an uppercase `E' in exponent form.
-  #       a   | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
-  #           | which is consisted from optional sign, "0x", fraction part
-  #           | as hexadecimal, "p", and exponential part as decimal.
-  #       A   | Equivalent to `a', but use uppercase `X' and `P'.
-  #
-  #     Field |  Other Format
-  #     ------+--------------------------------------------------------------
-  #       c   | Argument is the numeric code for a single character or
-  #           | a single character string itself.
-  #       p   | The valuing of argument.inspect.
-  #       s   | Argument is a string to be substituted.  If the format
-  #           | sequence contains a precision, at most that many characters
-  #           | will be copied.
-  #       %   | A percent sign itself will be displayed.  No argument taken.
-  #
-  # The flags modifies the behavior of the formats. The flag characters are:
-  #
-  #     Flag     | Applies to    | Meaning
-  #     ---------+---------------+-----------------------------------------
-  #     space    | bBdiouxX      | Leave a space at the start of
-  #              | aAeEfgG       | non-negative numbers.
-  #              | (numeric fmt) | For `o', `x', `X', `b' and `B', use
-  #              |               | a minus sign with absolute value for
-  #              |               | negative values.
-  #     ---------+---------------+-----------------------------------------
-  #     (digit)$ | all           | Specifies the absolute argument number
-  #              |               | for this field.  Absolute and relative
-  #              |               | argument numbers cannot be mixed in a
-  #              |               | sprintf string.
-  #     ---------+---------------+-----------------------------------------
-  #      #       | bBoxX         | Use an alternative format.
-  #              | aAeEfgG       | For the conversions `o', increase the precision
-  #              |               | until the first digit will be `0' if
-  #              |               | it is not formatted as complements.
-  #              |               | For the conversions `x', `X', `b' and `B'
-  #              |               | on non-zero, prefix the result with ``0x'',
-  #              |               | ``0X'', ``0b'' and ``0B'', respectively.
-  #              |               | For `a', `A', `e', `E', `f', `g', and 'G',
-  #              |               | force a decimal point to be added,
-  #              |               | even if no digits follow.
-  #              |               | For `g' and 'G', do not remove trailing zeros.
-  #     ---------+---------------+-----------------------------------------
-  #     +        | bBdiouxX      | Add a leading plus sign to non-negative
-  #              | aAeEfgG       | numbers.
-  #              | (numeric fmt) | For `o', `x', `X', `b' and `B', use
-  #              |               | a minus sign with absolute value for
-  #              |               | negative values.
-  #     ---------+---------------+-----------------------------------------
-  #     -        | all           | Left-justify the result of this conversion.
-  #     ---------+---------------+-----------------------------------------
-  #     0 (zero) | bBdiouxX      | Pad with zeros, not spaces.
-  #              | aAeEfgG       | For `o', `x', `X', `b' and `B', radix-1
-  #              | (numeric fmt) | is used for negative numbers formatted as
-  #              |               | complements.
-  #     ---------+---------------+-----------------------------------------
-  #     *        | all           | Use the next argument as the field width.
-  #              |               | If negative, left-justify the result. If the
-  #              |               | asterisk is followed by a number and a dollar
-  #              |               | sign, use the indicated argument as the width.
-  #
-  # Examples of flags:
-  #
-  #     # `+' and space flag specifies the sign of non-negative numbers.
-  #     sprintf("%d", 123)  #=> "123"
-  #     sprintf("%+d", 123) #=> "+123"
-  #     sprintf("% d", 123) #=> " 123"
-  #
-  #     # `#' flag for `o' increases number of digits to show `0'.
-  #     # `+' and space flag changes format of negative numbers.
-  #     sprintf("%o", 123)   #=> "173"
-  #     sprintf("%#o", 123)  #=> "0173"
-  #     sprintf("%+o", -123) #=> "-173"
-  #     sprintf("%o", -123)  #=> "..7605"
-  #     sprintf("%#o", -123) #=> "..7605"
-  #
-  #     # `#' flag for `x' add a prefix `0x' for non-zero numbers.
-  #     # `+' and space flag disables complements for negative numbers.
-  #     sprintf("%x", 123)   #=> "7b"
-  #     sprintf("%#x", 123)  #=> "0x7b"
-  #     sprintf("%+x", -123) #=> "-7b"
-  #     sprintf("%x", -123)  #=> "..f85"
-  #     sprintf("%#x", -123) #=> "0x..f85"
-  #     sprintf("%#x", 0)    #=> "0"
-  #
-  #     # `#' for `X' uses the prefix `0X'.
-  #     sprintf("%X", 123)  #=> "7B"
-  #     sprintf("%#X", 123) #=> "0X7B"
-  #
-  #     # `#' flag for `b' add a prefix `0b' for non-zero numbers.
-  #     # `+' and space flag disables complements for negative numbers.
-  #     sprintf("%b", 123)   #=> "1111011"
-  #     sprintf("%#b", 123)  #=> "0b1111011"
-  #     sprintf("%+b", -123) #=> "-1111011"
-  #     sprintf("%b", -123)  #=> "..10000101"
-  #     sprintf("%#b", -123) #=> "0b..10000101"
-  #     sprintf("%#b", 0)    #=> "0"
-  #
-  #     # `#' for `B' uses the prefix `0B'.
-  #     sprintf("%B", 123)  #=> "1111011"
-  #     sprintf("%#B", 123) #=> "0B1111011"
-  #
-  #     # `#' for `e' forces to show the decimal point.
-  #     sprintf("%.0e", 1)  #=> "1e+00"
-  #     sprintf("%#.0e", 1) #=> "1.e+00"
-  #
-  #     # `#' for `f' forces to show the decimal point.
-  #     sprintf("%.0f", 1234)  #=> "1234"
-  #     sprintf("%#.0f", 1234) #=> "1234."
-  #
-  #     # `#' for `g' forces to show the decimal point.
-  #     # It also disables stripping lowest zeros.
-  #     sprintf("%g", 123.4)   #=> "123.4"
-  #     sprintf("%#g", 123.4)  #=> "123.400"
-  #     sprintf("%g", 123456)  #=> "123456"
-  #     sprintf("%#g", 123456) #=> "123456."
-  #
-  # The field width is an optional integer, followed optionally by a period and a
-  # precision.  The width specifies the minimum number of characters that will be
-  # written to the result for this field.
-  #
-  # Examples of width:
-  #
-  #     # padding is done by spaces,       width=20
-  #     # 0 or radix-1.             <------------------>
-  #     sprintf("%20d", 123)   #=> "                 123"
-  #     sprintf("%+20d", 123)  #=> "                +123"
-  #     sprintf("%020d", 123)  #=> "00000000000000000123"
-  #     sprintf("%+020d", 123) #=> "+0000000000000000123"
-  #     sprintf("% 020d", 123) #=> " 0000000000000000123"
-  #     sprintf("%-20d", 123)  #=> "123                 "
-  #     sprintf("%-+20d", 123) #=> "+123                "
-  #     sprintf("%- 20d", 123) #=> " 123                "
-  #     sprintf("%020x", -123) #=> "..ffffffffffffffff85"
-  #
-  # For numeric fields, the precision controls the number of decimal places
-  # displayed.  For string fields, the precision determines the maximum number of
-  # characters to be copied from the string.  (Thus, the format sequence `%10.10s`
-  # will always contribute exactly ten characters to the result.)
-  #
-  # Examples of precisions:
-  #
-  #     # precision for `d', 'o', 'x' and 'b' is
-  #     # minimum number of digits               <------>
-  #     sprintf("%20.8d", 123)  #=> "            00000123"
-  #     sprintf("%20.8o", 123)  #=> "            00000173"
-  #     sprintf("%20.8x", 123)  #=> "            0000007b"
-  #     sprintf("%20.8b", 123)  #=> "            01111011"
-  #     sprintf("%20.8d", -123) #=> "           -00000123"
-  #     sprintf("%20.8o", -123) #=> "            ..777605"
-  #     sprintf("%20.8x", -123) #=> "            ..ffff85"
-  #     sprintf("%20.8b", -11)  #=> "            ..110101"
-  #
-  #     # "0x" and "0b" for `#x' and `#b' is not counted for
-  #     # precision but "0" for `#o' is counted.  <------>
-  #     sprintf("%#20.8d", 123)  #=> "            00000123"
-  #     sprintf("%#20.8o", 123)  #=> "            00000173"
-  #     sprintf("%#20.8x", 123)  #=> "          0x0000007b"
-  #     sprintf("%#20.8b", 123)  #=> "          0b01111011"
-  #     sprintf("%#20.8d", -123) #=> "           -00000123"
-  #     sprintf("%#20.8o", -123) #=> "            ..777605"
-  #     sprintf("%#20.8x", -123) #=> "          0x..ffff85"
-  #     sprintf("%#20.8b", -11)  #=> "          0b..110101"
-  #
-  #     # precision for `e' is number of
-  #     # digits after the decimal point           <------>
-  #     sprintf("%20.8e", 1234.56789) #=> "      1.23456789e+03"
-  #
-  #     # precision for `f' is number of
-  #     # digits after the decimal point               <------>
-  #     sprintf("%20.8f", 1234.56789) #=> "       1234.56789000"
-  #
-  #     # precision for `g' is number of
-  #     # significant digits                          <------->
-  #     sprintf("%20.8g", 1234.56789) #=> "           1234.5679"
-  #
-  #     #                                         <------->
-  #     sprintf("%20.8g", 123456789)  #=> "       1.2345679e+08"
-  #
-  #     # precision for `s' is
-  #     # maximum number of characters                    <------>
-  #     sprintf("%20.8s", "string test") #=> "            string t"
-  #
-  # Examples:
-  #
-  #     sprintf("%d %04x", 123, 123)               #=> "123 007b"
-  #     sprintf("%08b '%4s'", 123, 123)            #=> "01111011 ' 123'"
-  #     sprintf("%1$*2$s %2$d %1$s", "hello", 8)   #=> "   hello 8 hello"
-  #     sprintf("%1$*2$s %2$d", "hello", -8)       #=> "hello    -8"
-  #     sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23)   #=> "+1.23: 1.23:1.23"
-  #     sprintf("%u", -123)                        #=> "-123"
-  #
-  # For more complex formatting, Ruby supports a reference by name. %<name>s style
-  # uses format style, but %{name} style doesn't.
+  #   - sprintf(format_string *objects)  -> string
+  # -->
+  # Returns the string resulting from formatting `objects` into `format_string`.
   #
-  # Examples:
-  #     sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
-  #       #=> 1 : 2.000000
-  #     sprintf("%{foo}f", { :foo => 1 })
-  #       # => "1f"
+  # For details on `format_string`, see [Format
+  # Specifications](rdoc-ref:format_specifications.rdoc).
   #
   alias sprintf format
 
@@ -1482,15 +1199,15 @@ module Kernel : BasicObject
   # will be raised.
   #
   # If the optional *wrap* parameter is `true`, the loaded script will be executed
-  # under an anonymous module, protecting the calling program's global namespace.
-  # If the optional *wrap* parameter is a module, the loaded script will be
-  # executed under the given module. In no circumstance will any local variables
-  # in the loaded file be propagated to the loading environment.
+  # under an anonymous module. If the optional *wrap* parameter is a module, the
+  # loaded script will be executed under the given module. In no circumstance will
+  # any local variables in the loaded file be propagated to the loading
+  # environment.
   #
   def self?.load: (String filename, ?Module | bool) -> bool
 
   # <!--
-  #   rdoc-file=vm_eval.c
+  #   rdoc-file=kernel.rb
   #   - loop { block }
   #   - loop            -> an_enumerator
   # -->
@@ -1501,12 +1218,12 @@ module Kernel : BasicObject
   #     loop do
   #       print "Input: "
   #       line = gets
-  #       break if !line or line =~ /^qQ/
+  #       break if !line or line =~ /^q/i
   #       # ...
   #     end
   #
-  # StopIteration raised in the block breaks the loop.  In this case, loop returns
-  # the "result" value stored in the exception.
+  # A StopIteration raised in the block breaks the loop. In this case, loop
+  # returns the "result" value stored in the exception.
   #
   #     enum = Enumerator.new { |y|
   #       y << "one"
@@ -1518,143 +1235,120 @@ module Kernel : BasicObject
   #       puts enum.next
   #     } #=> :ok
   #
-  def self?.loop: () { (nil) -> untyped } -> bot
+  def self?.loop: () { () -> void } -> bot
                 | () -> ::Enumerator[nil, bot]
 
   # <!--
   #   rdoc-file=io.c
-  #   - open(path [, mode [, perm]] [, opt])                -> io or nil
-  #   - open(path [, mode [, perm]] [, opt]) {|io| block }  -> obj
+  #   - open(path, mode = 'r', perm = 0666, **opts)             -> io or nil
+  #   - open(path, mode = 'r', perm = 0666, **opts) {|io| ... } -> obj
   # -->
-  # Creates an IO object connected to the given stream, file, or subprocess.
+  # Creates an IO object connected to the given file.
   #
-  # If `path` does not start with a pipe character (`|`), treat it as the name of
-  # a file to open using the specified mode (defaulting to "r").
+  # This method has potential security vulnerabilities if called with untrusted
+  # input; see [Command Injection](rdoc-ref:command_injection.rdoc).
   #
-  # The `mode` is either a string or an integer.  If it is an integer, it must be
-  # bitwise-or of open(2) flags, such as File::RDWR or File::EXCL.  If it is a
-  # string, it is either "fmode", "fmode:ext_enc", or "fmode:ext_enc:int_enc".
+  # With no block given, file stream is returned:
   #
-  # See the documentation of IO.new for full documentation of the `mode` string
-  # directives.
+  #     open('t.txt') # => #<File:t.txt>
   #
-  # If a file is being created, its initial permissions may be set using the
-  # `perm` parameter.  See File.new and the open(2) and chmod(2) man pages for a
-  # description of permissions.
+  # With a block given, calls the block with the open file stream, then closes the
+  # stream:
   #
-  # If a block is specified, it will be invoked with the IO object as a parameter,
-  # and the IO will be automatically closed when the block terminates.  The call
-  # returns the value of the block.
+  #     open('t.txt') {|f| p f } # => #<File:t.txt (closed)>
   #
-  # If `path` starts with a pipe character (`"|"`), a subprocess is created,
-  # connected to the caller by a pair of pipes.  The returned IO object may be
-  # used to write to the standard input and read from the standard output of this
-  # subprocess.
+  # Output:
   #
-  # If the command following the pipe is a single minus sign (`"|-"`), Ruby forks,
-  # and this subprocess is connected to the parent.  If the command is not `"-"`,
-  # the subprocess runs the command.  Note that the command may be processed by
-  # shell if it contains shell metacharacters.
+  #     #<File:t.txt>
   #
-  # When the subprocess is Ruby (opened via `"|-"`), the `open` call returns
-  # `nil`.  If a block is associated with the open call, that block will run twice
-  # --- once in the parent and once in the child.
+  # See File.open for details.
   #
-  # The block parameter will be an IO object in the parent and `nil` in the child.
-  # The parent's `IO` object will be connected to the child's $stdin and $stdout.
-  # The subprocess will be terminated at the end of the block.
+  def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
+                | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
+
+  # <!--
+  #   rdoc-file=io.c
+  #   - print(*objects) -> nil
+  # -->
+  # Equivalent to `$stdout.print(*objects)`, this method is the straightforward
+  # way to write to `$stdout`.
   #
-  # ### Examples
+  # Writes the given objects to `$stdout`; returns `nil`. Appends the output
+  # record separator `$OUTPUT_RECORD_SEPARATOR` `$\`), if it is not `nil`.
   #
-  # Reading from "testfile":
+  # With argument `objects` given, for each object:
   #
-  #     open("testfile") do |f|
-  #       print f.gets
-  #     end
+  # *   Converts via its method `to_s` if not a string.
+  # *   Writes to `stdout`.
+  # *   If not the last object, writes the output field separator
+  #     `$OUTPUT_FIELD_SEPARATOR` (`$,` if it is not `nil`.
   #
-  # Produces:
+  # With default separators:
   #
-  #     This is line one
+  #     objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
+  #     $OUTPUT_RECORD_SEPARATOR
+  #     $OUTPUT_FIELD_SEPARATOR
+  #     print(*objects)
   #
-  # Open a subprocess and read its output:
+  # Output:
   #
-  #     cmd = open("|date")
-  #     print cmd.gets
-  #     cmd.close
+  #     nil
+  #     nil
+  #     00.00/10+0izerozero
   #
-  # Produces:
+  # With specified separators:
   #
-  #     Wed Apr  9 08:56:31 CDT 2003
+  #     $OUTPUT_RECORD_SEPARATOR = "\n"
+  #     $OUTPUT_FIELD_SEPARATOR = ','
+  #     print(*objects)
   #
-  # Open a subprocess running the same Ruby program:
+  # Output:
   #
-  #     f = open("|-", "w+")
-  #     if f.nil?
-  #       puts "in Child"
-  #       exit
-  #     else
-  #       puts "Got: #{f.gets}"
-  #     end
+  #     0,0.0,0/1,0+0i,zero,zero
   #
-  # Produces:
+  # With no argument given, writes the content of `$_` (which is usually the most
+  # recent user input):
   #
-  #     Got: in Child
+  #     gets  # Sets $_ to the most recent user input.
+  #     print # Prints $_.
   #
-  # Open a subprocess using a block to receive the IO object:
-  #
-  #     open "|-" do |f|
-  #       if f then
-  #         # parent process
-  #         puts "Got: #{f.gets}"
-  #       else
-  #         # child process
-  #         puts "in Child"
-  #       end
-  #     end
-  #
-  # Produces:
-  #
-  #     Got: in Child
-  #
-  def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
-                | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
+  def self?.print: (*_ToS args) -> nil
 
   # <!--
   #   rdoc-file=io.c
-  #   - print(obj, ...)    -> nil
+  #   - printf(format_string, *objects)               -> nil
+  #   - printf(io, format_string, *objects) -> nil
   # -->
-  # Prints each object in turn to `$stdout`. If the output field separator (`$,`)
-  # is not `nil`, its contents will appear between each field. If the output
-  # record separator (`$\`) is not `nil`, it will be appended to the output. If no
-  # arguments are given, prints `$_`. Objects that aren't strings will be
-  # converted by calling their `to_s` method.
+  # Equivalent to:
   #
-  #     print "cat", [1,2,3], 99, "\n"
-  #     $, = ", "
-  #     $\ = "\n"
-  #     print "cat", [1,2,3], 99
+  #     io.write(sprintf(format_string, *objects))
   #
-  # *produces:*
+  # For details on `format_string`, see [Format
+  # Specifications](rdoc-ref:format_specifications.rdoc).
   #
-  #     cat12399
-  #     cat, 1, 2, 3, 99
+  # With the single argument `format_string`, formats `objects` into the string,
+  # then writes the formatted string to $stdout:
   #
-  def self?.print: (*Kernel args) -> nil
-
-  # <!--
-  #   rdoc-file=io.c
-  #   - printf(io, string [, obj ... ])    -> nil
-  #   - printf(string [, obj ... ])        -> nil
-  # -->
-  # Equivalent to:
-  #     io.write(sprintf(string, obj, ...))
+  #     printf('%4.4d %10s %2.2f', 24, 24, 24.0)
+  #
+  # Output (on $stdout):
+  #
+  #     0024         24 24.00#
+  #
+  # With arguments `io` and `format_string`, formats `objects` into the string,
+  # then writes the formatted string to `io`:
+  #
+  #     printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0)
+  #
+  # Output (on $stderr):
+  #
+  #     0024         24 24.00# => nil
   #
-  # or
-  #     $stdout.write(sprintf(string, obj, ...))
+  # With no arguments, does nothing.
   #
-  def self?.printf: (IO arg0, String arg1, *untyped args) -> nil
-                  | (String arg1, *untyped args) -> nil
-                  | () -> nil
+  def self?.printf: () -> nil
+                  | (String fmt, *untyped args) -> nil
+                  | (_Writer io, string fmt, *untyped args) -> nil
 
   # <!--
   #   rdoc-file=proc.c
@@ -1662,7 +1356,7 @@ module Kernel : BasicObject
   # -->
   # Equivalent to Proc.new.
   #
-  def self?.proc: () { () -> untyped } -> Proc
+  def self?.proc: () { (?) -> untyped } -> Proc
 
   # <!--
   #   rdoc-file=proc.c
@@ -1675,47 +1369,59 @@ module Kernel : BasicObject
 
   # <!--
   #   rdoc-file=io.c
-  #   - putc(int)   -> int
+  #   - putc(int) -> int
   # -->
   # Equivalent to:
   #
   #     $stdout.putc(int)
   #
-  # Refer to the documentation for IO#putc for important information regarding
-  # multi-byte characters.
+  # See IO#putc for important information regarding multi-byte characters.
   #
-  def self?.putc: (Integer arg0) -> Integer
-                | (String arg0) -> String
+  def self?.putc: [T < _ToInt] (T chr) -> T
+                | (String chr) -> String
 
   # <!--
   #   rdoc-file=io.c
-  #   - puts(obj, ...)    -> nil
+  #   - puts(*objects)    -> nil
   # -->
   # Equivalent to
   #
-  #     $stdout.puts(obj, ...)
+  #     $stdout.puts(objects)
   #
-  def self?.puts: (*untyped arg0) -> NilClass
+  def self?.puts: (*_ToS objects) -> nil
 
   # <!--
   #   rdoc-file=io.c
-  #   - p(obj)              -> obj
-  #   - p(obj1, obj2, ...)  -> [obj, ...]
-  #   - p()                 -> nil
+  #   - p(object)   -> obj
+  #   - p(*objects) -> array of objects
+  #   - p           -> nil
   # -->
-  # For each object, directly writes *obj*.`inspect` followed by a newline to the
-  # program's standard output.
+  # For each object `obj`, executes:
   #
-  #     S = Struct.new(:name, :state)
-  #     s = S['dave', 'TX']
-  #     p s
+  #     $stdout.write(obj.inspect, "\n")
   #
-  # *produces:*
+  # With one object given, returns the object; with multiple objects given,
+  # returns an array containing the objects; with no object given, returns `nil`.
+  #
+  # Examples:
+  #
+  #     r = Range.new(0, 4)
+  #     p r                 # => 0..4
+  #     p [r, r, r]         # => [0..4, 0..4, 0..4]
+  #     p                   # => nil
   #
-  #     #<S name="dave", state="TX">
+  # Output:
   #
-  def self?.p: [T] (T arg0) -> T
-             | (*untyped arg0) -> Array[untyped]
+  #     0..4
+  #     [0..4, 0..4, 0..4]
+  #
+  # Kernel#p is designed for debugging purposes. Ruby implementations may define
+  # Kernel#p to be uninterruptible in whole or in part. On CRuby, Kernel#p's
+  # writing of data is uninterruptible.
+  #
+  def self?.p: [T < _Inspect] (T arg0) -> T
+             | (_Inspect arg0, _Inspect arg1, *_Inspect rest) -> Array[_Inspect]
+             | () -> nil
 
   # <!--
   #   rdoc-file=lib/pp.rb
@@ -1723,10 +1429,11 @@ module Kernel : BasicObject
   # -->
   # prints arguments in pretty form.
   #
-  # pp returns argument(s).
+  # `#pp` returns argument(s).
   #
   def self?.pp: [T] (T arg0) -> T
-              | (*untyped arg0) -> Array[untyped]
+              | (untyped, untyped, *untyped) -> Array[untyped]
+              | () -> nil
 
   # <!--
   #   rdoc-file=random.c
@@ -1744,7 +1451,7 @@ module Kernel : BasicObject
   #     rand(100)   #=> 12
   #
   # When `max` is a Range, `rand` returns a random number where
-  # range.member?(number) == true.
+  # `range.member?(number) == true`.
   #
   # Negative or floating point values for `max` are allowed, but may give
   # surprising results.
@@ -1758,65 +1465,98 @@ module Kernel : BasicObject
   #
   # See also Random.rand.
   #
-  def self?.rand: () -> Float
-                | (Integer arg0) -> Integer
-                | (::Range[Integer] arg0) -> Integer
-                | (::Range[Float] arg0) -> Float
+  def self?.rand: (?0) -> Float
+                | (int arg0) -> Integer
+                | (::Range[Integer] arg0) -> Integer?
+                | (::Range[Float] arg0) -> Float?
 
   # <!--
   #   rdoc-file=io.c
-  #   - readline(sep=$/)     -> string
-  #   - readline(limit)      -> string
-  #   - readline(sep, limit) -> string
+  #   - readline(sep = $/, chomp: false)   -> string
+  #   - readline(limit, chomp: false)      -> string
+  #   - readline(sep, limit, chomp: false) -> string
   # -->
-  # Equivalent to Kernel::gets, except `readline` raises `EOFError` at end of
-  # file.
+  # Equivalent to method Kernel#gets, except that it raises an exception if called
+  # at end-of-stream:
+  #
+  #     $ cat t.txt | ruby -e "p readlines; readline"
+  #     ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]
+  #     in `readline': end of file reached (EOFError)
+  #
+  # Optional keyword argument `chomp` specifies whether line separators are to be
+  # omitted.
   #
   def self?.readline: (?String arg0, ?Integer arg1) -> String
 
   # <!--
   #   rdoc-file=io.c
-  #   - readlines(sep=$/)     -> array
-  #   - readlines(limit)      -> array
-  #   - readlines(sep, limit) -> array
+  #   - readlines(sep = $/, chomp: false, **enc_opts)   -> array
+  #   - readlines(limit, chomp: false, **enc_opts)       -> array
+  #   - readlines(sep, limit, chomp: false, **enc_opts) -> array
   # -->
-  # Returns an array containing the lines returned by calling `Kernel.gets(*sep*)`
-  # until the end of file.
+  # Returns an array containing the lines returned by calling Kernel#gets until
+  # the end-of-stream is reached; (see [Line IO](rdoc-ref:IO@Line+IO)).
   #
-  def self?.readlines: (?String arg0, ?Integer arg1) -> ::Array[String]
-
-  # <!--
-  #   rdoc-file=load.c
-  #   - require(name)    -> true or false
-  # -->
-  # Loads the given `name`, returning `true` if successful and `false` if the
-  # feature is already loaded.
+  # With only string argument `sep` given, returns the remaining lines as
+  # determined by line separator `sep`, or `nil` if none; see [Line
+  # Separator](rdoc-ref:IO@Line+Separator):
+  #
+  #     # Default separator.
+  #     $ cat t.txt | ruby -e "p readlines"
+  #     ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]
+  #
+  #     # Specified separator.
+  #     $ cat t.txt | ruby -e "p readlines 'li'"
+  #     ["First li", "ne\nSecond li", "ne\n\nFourth li", "ne\nFifth li", "ne\n"]
+  #
+  #     # Get-all separator.
+  #     $ cat t.txt | ruby -e "p readlines nil"
+  #     ["First line\nSecond line\n\nFourth line\nFifth line\n"]
+  #
+  #     # Get-paragraph separator.
+  #     $ cat t.txt | ruby -e "p readlines ''"
+  #     ["First line\nSecond line\n\n", "Fourth line\nFifth line\n"]
+  #
+  # With only integer argument `limit` given, limits the number of bytes in the
+  # line; see [Line Limit](rdoc-ref:IO@Line+Limit):
+  #
+  #     $cat t.txt | ruby -e "p readlines 10"
+  #     ["First line", "\n", "Second lin", "e\n", "\n", "Fourth lin", "e\n", "Fifth line", "\n"]
+  #
+  #     $cat t.txt | ruby -e "p readlines 11"
+  #     ["First line\n", "Second line", "\n", "\n", "Fourth line", "\n", "Fifth line\n"]
+  #
+  #     $cat t.txt | ruby -e "p readlines 12"
+  #     ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]
+  #
+  # With arguments `sep` and `limit` given, combines the two behaviors (see [Line
+  # Separator and Line Limit](rdoc-ref:IO@Line+Separator+and+Line+Limit)).
   #
-  # If the filename neither resolves to an absolute path nor starts with './' or
-  # '../', the file will be searched for in the library directories listed in
-  # `$LOAD_PATH` (`$:`). If the filename starts with './' or '../', resolution is
-  # based on Dir.pwd.
+  # Optional keyword argument `chomp` specifies whether line separators are to be
+  # omitted:
   #
-  # If the filename has the extension ".rb", it is loaded as a source file; if the
-  # extension is ".so", ".o", or ".dll", or the default shared library extension
-  # on the current platform, Ruby loads the shared library as a Ruby extension.
-  # Otherwise, Ruby tries adding ".rb", ".so", and so on to the name until found.
-  # If the file named cannot be found, a LoadError will be raised.
+  #     $ cat t.txt | ruby -e "p readlines(chomp: true)"
+  #     ["First line", "Second line", "", "Fourth line", "Fifth line"]
   #
-  # For Ruby extensions the filename given may use any shared library extension.
-  # For example, on Linux the socket extension is "socket.so" and `require
-  # 'socket.dll'` will load the socket extension.
+  # Optional keyword arguments `enc_opts` specify encoding options; see [Encoding
+  # options](rdoc-ref:encodings.rdoc@Encoding+Options).
   #
-  # The absolute path of the loaded file is added to `$LOADED_FEATURES` (`$"`).  A
-  # file will not be loaded again if its path already appears in `$"`.  For
-  # example, `require 'a'; require './a'` will not load `a.rb` again.
+  def self?.readlines: (?string sep, ?int limit, ?chomp: boolish) -> ::Array[String]
+
+  # <!--
+  #   rdoc-file=lib/rubygems/core_ext/kernel_require.rb
+  #   - require(path)
+  # -->
+  # When RubyGems is required, Kernel#require is replaced with our own which is
+  # capable of loading gems on demand.
   #
-  #     require "my-library.rb"
-  #     require "db-driver"
+  # When you call `require 'x'`, this is what happens:
+  # *   If the file can be loaded from the existing Ruby loadpath, it is.
+  # *   Otherwise, installed gems are searched for a file that matches. If it's
+  #     found in gem 'y', that gem is activated (added to the loadpath).
   #
-  # Any constants or globals within the loaded source file will be available in
-  # the calling program's global namespace. However, local variables will not be
-  # propagated to the loading environment.
+  # The normal `require` functionality of returning false if that file has already
+  # been loaded is preserved.
   #
   def self?.require: (String path) -> bool
 
@@ -1824,33 +1564,49 @@ module Kernel : BasicObject
   #   rdoc-file=load.c
   #   - require_relative(string) -> true or false
   # -->
-  # Ruby tries to load the library named *string* relative to the requiring file's
-  # path.  If the file's path cannot be determined a LoadError is raised. If a
-  # file is loaded `true` is returned and false otherwise.
+  # Ruby tries to load the library named *string* relative to the directory
+  # containing the requiring file.  If the file does not exist a LoadError is
+  # raised. Returns `true` if the file was loaded and `false` if the file was
+  # already loaded before.
   #
   def self?.require_relative: (String feature) -> bool
 
   # <!--
   #   rdoc-file=io.c
-  #   - IO.select(read_array [, write_array [, error_array [, timeout]]]) -> array or nil
+  #   - IO.select(read_ios, write_ios = [], error_ios = [], timeout = nil) -> array or nil
   # -->
-  # Calls select(2) system call. It monitors given arrays of IO objects, waits
-  # until one or more of IO objects are ready for reading, are ready for writing,
-  # and have pending exceptions respectively, and returns an array that contains
-  # arrays of those IO objects.  It will return `nil` if optional *timeout* value
-  # is given and no IO object is ready in *timeout* seconds.
+  # Invokes system call [select(2)](https://linux.die.net/man/2/select), which
+  # monitors multiple file descriptors, waiting until one or more of the file
+  # descriptors becomes ready for some class of I/O operation.
+  #
+  # Not implemented on all platforms.
+  #
+  # Each of the arguments `read_ios`, `write_ios`, and `error_ios` is an array of
+  # IO objects.
+  #
+  # Argument `timeout` is a numeric value (such as integer or float) timeout
+  # interval in seconds.
+  #
+  # The method monitors the IO objects given in all three arrays, waiting for some
+  # to be ready; returns a 3-element array whose elements are:
+  #
+  # *   An array of the objects in `read_ios` that are ready for reading.
+  # *   An array of the objects in `write_ios` that are ready for writing.
+  # *   An array of the objects in `error_ios` have pending exceptions.
+  #
+  # If no object becomes ready within the given `timeout`, `nil` is returned.
   #
   # IO.select peeks the buffer of IO objects for testing readability. If the IO
   # buffer is not empty, IO.select immediately notifies readability.  This "peek"
   # only happens for IO objects.  It does not happen for IO-like objects such as
   # OpenSSL::SSL::SSLSocket.
   #
-  # The best way to use IO.select is invoking it after nonblocking methods such as
-  # #read_nonblock, #write_nonblock, etc.  The methods raise an exception which is
-  # extended by IO::WaitReadable or IO::WaitWritable.  The modules notify how the
-  # caller should wait with IO.select.  If IO::WaitReadable is raised, the caller
-  # should wait for reading.  If IO::WaitWritable is raised, the caller should
-  # wait for writing.
+  # The best way to use IO.select is invoking it after non-blocking methods such
+  # as #read_nonblock, #write_nonblock, etc.  The methods raise an exception which
+  # is extended by IO::WaitReadable or IO::WaitWritable.  The modules notify how
+  # the caller should wait with IO.select.  If IO::WaitReadable is raised, the
+  # caller should wait for reading.  If IO::WaitWritable is raised, the caller
+  # should wait for writing.
   #
   # So, blocking read (#readpartial) can be emulated using #read_nonblock and
   # IO.select as follows:
@@ -1865,7 +1621,7 @@ module Kernel : BasicObject
   #       retry
   #     end
   #
-  # Especially, the combination of nonblocking methods and IO.select is preferred
+  # Especially, the combination of non-blocking methods and IO.select is preferred
   # for IO like objects such as OpenSSL::SSL::SSLSocket.  It has #to_io method to
   # return underlying IO object.  IO.select calls #to_io to obtain the file
   # descriptor to wait.
@@ -1891,13 +1647,13 @@ module Kernel : BasicObject
   # blocking. So, the caller should wait for ready for writability as above
   # example.
   #
-  # The combination of nonblocking methods and IO.select is also useful for
+  # The combination of non-blocking methods and IO.select is also useful for
   # streams such as tty, pipe socket socket when multiple processes read from a
   # stream.
   #
   # Finally, Linux kernel developers don't guarantee that readability of select(2)
-  # means readability of following read(2) even for a single process. See
-  # select(2) manual on GNU/Linux system.
+  # means readability of following read(2) even for a single process; see
+  # [select(2)](https://linux.die.net/man/2/select)
   #
   # Invoking IO.select before IO#readpartial works well as usual. However it is
   # not the best way to use IO.select.
@@ -1924,18 +1680,7 @@ module Kernel : BasicObject
   #       string = string.byteslice(written..-1)
   #     end
   #
-  # ### Parameters
-  # read_array
-  # :   an array of IO objects that wait until ready for read
-  # write_array
-  # :   an array of IO objects that wait until ready for write
-  # error_array
-  # :   an array of IO objects that wait for exceptions
-  # timeout
-  # :   a numeric value in second
-  #
-  #
-  # ### Example
+  # Example:
   #
   #     rp, wp = IO.pipe
   #     mesg = "ping "
@@ -1957,7 +1702,7 @@ module Kernel : BasicObject
   #       end
   #     }
   #
-  # *produces:*
+  # Output:
   #
   #     ping pong
   #     ping pong
@@ -1965,117 +1710,121 @@ module Kernel : BasicObject
   #     (snipped)
   #     ping
   #
-  def self?.select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Integer timeout) -> ::Array[String]
+  def self?.select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Time::_Timeout timeout) -> ::Array[String]
 
   # <!--
   #   rdoc-file=process.c
-  #   - sleep([duration])    -> integer
+  #   - sleep(secs = nil) -> slept_secs
   # -->
-  # Suspends the current thread for *duration* seconds (which may be any number,
-  # including a `Float` with fractional seconds). Returns the actual number of
-  # seconds slept (rounded), which may be less than that asked for if another
-  # thread calls Thread#run. Called without an argument, sleep() will sleep
-  # forever.
-  #
-  #     Time.new    #=> 2008-03-08 19:56:19 +0900
-  #     sleep 1.2   #=> 1
-  #     Time.new    #=> 2008-03-08 19:56:20 +0900
-  #     sleep 1.9   #=> 2
-  #     Time.new    #=> 2008-03-08 19:56:22 +0900
-  #
-  def self?.sleep: () -> bot
-                 | ((Integer | Float | _Divmod) duration) -> Integer
+  # Suspends execution of the current thread for the number of seconds specified
+  # by numeric argument `secs`, or forever if `secs` is `nil`; returns the integer
+  # number of seconds suspended (rounded).
+  #
+  #     Time.new  # => 2008-03-08 19:56:19 +0900
+  #     sleep 1.2 # => 1
+  #     Time.new  # => 2008-03-08 19:56:20 +0900
+  #     sleep 1.9 # => 2
+  #     Time.new  # => 2008-03-08 19:56:22 +0900
+  #
+  def self?.sleep: (?nil) -> bot
+                 | (Time::_Timeout duration) -> Integer
 
+  %a{steep:deprecated}
   interface _Divmod
     def divmod: (Numeric) -> [ Numeric, Numeric ]
   end
 
   # <!--
   #   rdoc-file=io.c
-  #   - syscall(num [, args...])   -> integer
+  #   - syscall(integer_callno, *arguments)   -> integer
   # -->
-  # Calls the operating system function identified by *num* and returns the result
-  # of the function or raises SystemCallError if it failed.
+  # Invokes Posix system call [syscall(2)](https://linux.die.net/man/2/syscall),
+  # which calls a specified function.
   #
-  # Arguments for the function can follow *num*. They must be either `String`
-  # objects or `Integer` objects. A `String` object is passed as a pointer to the
-  # byte sequence. An `Integer` object is passed as an integer whose bit size is
-  # the same as a pointer. Up to nine parameters may be passed.
+  # Calls the operating system function identified by `integer_callno`; returns
+  # the result of the function or raises SystemCallError if it failed. The effect
+  # of the call is platform-dependent. The arguments and returned value are
+  # platform-dependent.
   #
-  # The function identified by *num* is system dependent. On some Unix systems,
-  # the numbers may be obtained from a header file called `syscall.h`.
+  # For each of `arguments`: if it is an integer, it is passed directly; if it is
+  # a string, it is interpreted as a binary sequence of bytes. There may be as
+  # many as nine such arguments.
   #
-  #     syscall 4, 1, "hello\n", 6   # '4' is write(2) on our box
+  # Arguments `integer_callno` and `argument`, as well as the returned value, are
+  # platform-dependent.
   #
-  # *produces:*
-  #
-  #     hello
+  # Note: Method `syscall` is essentially unsafe and unportable. The DL (Fiddle)
+  # library is preferred for safer and a bit more portable programming.
   #
-  # Calling `syscall` on a platform which does not have any way to an arbitrary
-  # system function just fails with NotImplementedError.
-  #
-  # **Note:** `syscall` is essentially unsafe and unportable. Feel free to shoot
-  # your foot. The DL (Fiddle) library is preferred for safer and a bit more
-  # portable programming.
+  # Not implemented on all platforms.
   #
   def self?.syscall: (Integer num, *untyped args) -> untyped
 
   # <!--
   #   rdoc-file=file.c
-  #   - test(cmd, file1 [, file2] ) -> obj
-  # -->
-  # Uses the character `cmd` to perform various tests on `file1` (first table
-  # below) or on `file1` and `file2` (second table).
-  #
-  # File tests on a single file:
-  #
-  #     Cmd    Returns   Meaning
-  #     "A"  | Time    | Last access time for file1
-  #     "b"  | boolean | True if file1 is a block device
-  #     "c"  | boolean | True if file1 is a character device
-  #     "C"  | Time    | Last change time for file1
-  #     "d"  | boolean | True if file1 exists and is a directory
-  #     "e"  | boolean | True if file1 exists
-  #     "f"  | boolean | True if file1 exists and is a regular file
-  #     "g"  | boolean | True if file1 has the \CF{setgid} bit
-  #          |         | set (false under NT)
-  #     "G"  | boolean | True if file1 exists and has a group
-  #          |         | ownership equal to the caller's group
-  #     "k"  | boolean | True if file1 exists and has the sticky bit set
-  #     "l"  | boolean | True if file1 exists and is a symbolic link
-  #     "M"  | Time    | Last modification time for file1
-  #     "o"  | boolean | True if file1 exists and is owned by
-  #          |         | the caller's effective uid
-  #     "O"  | boolean | True if file1 exists and is owned by
-  #          |         | the caller's real uid
-  #     "p"  | boolean | True if file1 exists and is a fifo
-  #     "r"  | boolean | True if file1 is readable by the effective
-  #          |         | uid/gid of the caller
-  #     "R"  | boolean | True if file is readable by the real
-  #          |         | uid/gid of the caller
-  #     "s"  | int/nil | If file1 has nonzero size, return the size,
-  #          |         | otherwise return nil
-  #     "S"  | boolean | True if file1 exists and is a socket
-  #     "u"  | boolean | True if file1 has the setuid bit set
-  #     "w"  | boolean | True if file1 exists and is writable by
-  #          |         | the effective uid/gid
-  #     "W"  | boolean | True if file1 exists and is writable by
-  #          |         | the real uid/gid
-  #     "x"  | boolean | True if file1 exists and is executable by
-  #          |         | the effective uid/gid
-  #     "X"  | boolean | True if file1 exists and is executable by
-  #          |         | the real uid/gid
-  #     "z"  | boolean | True if file1 exists and has a zero length
-  #
-  # Tests that take two files:
-  #
-  #     "-"  | boolean | True if file1 and file2 are identical
-  #     "="  | boolean | True if the modification times of file1
-  #          |         | and file2 are equal
-  #     "<"  | boolean | True if the modification time of file1
-  #          |         | is prior to that of file2
-  #     ">"  | boolean | True if the modification time of file1
-  #          |         | is after that of file2
+  #   - test(char, path0, path1 = nil) -> object
+  # -->
+  # Performs a test on one or both of the *filesystem entities* at the given paths
+  # `path0` and `path1`:
+  # *   Each path `path0` or `path1` points to a file, directory, device, pipe,
+  #     etc.
+  # *   Character `char` selects a specific test.
+  # The tests:
+  # *   Each of these tests operates only on the entity at `path0`,
+  #      and returns `true` or `false`;
+  #      for a non-existent entity, returns `false` (does not raise exception):
+  #  Character  |Test
+  # ------------|-------------------------------------------------------------------------
+  # <tt>'b'</tt>|Whether the entity is a block device.
+  # <tt>'c'</tt>|Whether the entity is a character device.
+  # <tt>'d'</tt>|Whether the entity is a directory.
+  # <tt>'e'</tt>|Whether the entity is an existing entity.
+  # <tt>'f'</tt>|Whether the entity is an existing regular file.
+  # <tt>'g'</tt>|Whether the entity's setgid bit is set.
+  # <tt>'G'</tt>|Whether the entity's group ownership is equal to the caller's.
+  # <tt>'k'</tt>|Whether the entity's sticky bit is set.
+  # <tt>'l'</tt>|Whether the entity is a symbolic link.
+  # <tt>'o'</tt>|Whether the entity is owned by the caller's effective uid.
+  # <tt>'O'</tt>|Like <tt>'o'</tt>, but uses the real uid (not the effective uid).
+  # <tt>'p'</tt>|Whether the entity is a FIFO device (named pipe).
+  # <tt>'r'</tt>|Whether the entity is readable by the caller's effective uid/gid.
+  # <tt>'R'</tt>|Like <tt>'r'</tt>, but uses the real uid/gid (not the effective uid/gid).
+  # <tt>'S'</tt>|Whether the entity is a socket.
+  # <tt>'u'</tt>|Whether the entity's setuid bit is set.
+  # <tt>'w'</tt>|Whether the entity is writable by the caller's effective uid/gid.
+  # <tt>'W'</tt>|Like <tt>'w'</tt>, but uses the real uid/gid (not the effective uid/gid).
+  # <tt>'x'</tt>|Whether the entity is executable by the caller's effective uid/gid.
+  # <tt>'X'</tt>|Like <tt>'x'</tt>, but uses the real uid/gid (not the effective uid/git).
+  # <tt>'z'</tt>|Whether the entity exists and is of length zero.
+  # *   This test operates only on the entity at `path0`,
+  #      and returns an integer size or `nil`:
+  #  Character  |Test
+  # ------------|--------------------------------------------------------------------------------------------
+  # <tt>'s'</tt>|Returns positive integer size if the entity exists and has non-zero length, +nil+ otherwise.
+  # *   Each of these tests operates only on the entity at `path0`,
+  #      and returns a Time object;
+  #      raises an exception if the entity does not exist:
+  #  Character  |Test
+  # ------------|--------------------------------------
+  # <tt>'A'</tt>|Last access time for the entity.
+  # <tt>'C'</tt>|Last change time for the entity.
+  # <tt>'M'</tt>|Last modification time for the entity.
+  # *   Each of these tests operates on the modification time (`mtime`)
+  #      of each of the entities at `path0` and `path1`,
+  #      and returns a `true` or `false`;
+  #      returns `false` if either entity does not exist:
+  #  Character  |Test
+  # ------------|---------------------------------------------------------------
+  # <tt>'<'</tt>|Whether the `mtime` at `path0` is less than that at `path1`.
+  # <tt>'='</tt>|Whether the `mtime` at `path0` is equal to that at `path1`.
+  # <tt>'>'</tt>|Whether the `mtime` at `path0` is greater than that at `path1`.
+  # *   This test operates on the content of each of the entities at `path0` and
+  #     `path1`,
+  #      and returns a `true` or `false`;
+  #      returns `false` if either entity does not exist:
+  #  Character  |Test
+  # ------------|---------------------------------------------
+  # <tt>'-'</tt>|Whether the entities exist and are identical.
   #
   def self?.test: (String | Integer cmd, String | IO file1, ?String | IO file2) -> (TrueClass | FalseClass | Time | nil | Integer)
 
@@ -2088,7 +1837,7 @@ module Kernel : BasicObject
   # optional second parameter supplies a return value for the `catch` block, which
   # otherwise defaults to `nil`. For examples, see Kernel::catch.
   #
-  def self?.throw: (Object tag, ?untyped obj) -> bot
+  def self?.throw: (untyped tag, ?untyped obj) -> bot
 
   # <!--
   #   rdoc-file=warning.rb
@@ -2099,420 +1848,1249 @@ module Kernel : BasicObject
   # newline character to the string if the string does not end in a newline, and
   # calls Warning.warn with the string.
   #
-  #       warn("warning 1", "warning 2")
+  #     warn("warning 1", "warning 2")
   #
-  #     <em>produces:</em>
+  # *produces:*
   #
-  #       warning 1
-  #       warning 2
+  #     warning 1
+  #     warning 2
   #
   # If the `uplevel` keyword argument is given, the string will be prepended with
   # information for the given caller frame in the same format used by the
   # `rb_warn` C function.
   #
-  #       # In baz.rb
-  #       def foo
-  #         warn("invalid call to foo", uplevel: 1)
-  #       end
+  #     # In baz.rb
+  #     def foo
+  #       warn("invalid call to foo", uplevel: 1)
+  #     end
   #
-  #       def bar
-  #         foo
-  #       end
+  #     def bar
+  #       foo
+  #     end
   #
-  #       bar
+  #     bar
   #
-  #     <em>produces:</em>
+  # *produces:*
   #
-  #       baz.rb:6: warning: invalid call to foo
+  #     baz.rb:6: warning: invalid call to foo
   #
   # If `category` keyword argument is given, passes the category to
-  # `Warning.warn`.  The category given must be be one of the following
-  # categories:
+  # `Warning.warn`.  The category given must be one of the following categories:
   #
   # :deprecated
   # :   Used for warning for deprecated functionality that may be removed in the
   #     future.
+  #
   # :experimental
   # :   Used for experimental features that may change in future releases.
   #
-  def self?.warn: (*untyped msg, ?uplevel: Integer | nil, ?category: :deprecated | :experimental | nil) -> NilClass
+  # :performance
+  # :   Used for warning about APIs or pattern that have negative performance
+  #     impact
+  #
+  def self?.warn: (*_ToS msg, ?uplevel: int?, ?category: Warning::category?) -> nil
 
   # <!--
   #   rdoc-file=process.c
-  #   - exec([env,] command... [,options])
+  #   - exec([env, ] command_line, options = {})
+  #   - exec([env, ] exe_path, *args, options  = {})
   # -->
-  # Replaces the current process by running the given external *command*, which
-  # can take one of the following forms:
+  # Replaces the current process by doing one of the following:
+  #
+  # *   Passing string `command_line` to the shell.
+  # *   Invoking the executable at `exe_path`.
+  #
+  # This method has potential security vulnerabilities if called with untrusted
+  # input; see [Command Injection](rdoc-ref:command_injection.rdoc).
+  #
+  # The new process is created using the [exec system
+  # call](https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/e
+  # xecve.html); it may inherit some of its environment from the calling program
+  # (possibly including open file descriptors).
   #
-  # `exec(commandline)`
-  # :   command line string which is passed to the standard shell
-  # `exec(cmdname, arg1, ...)`
-  # :   command name and one or more arguments (no shell)
-  # `exec([cmdname, argv0], arg1, ...)`
-  # :   command name, [argv](0) and zero or more arguments (no shell)
+  # Argument `env`, if given, is a hash that affects `ENV` for the new process;
+  # see [Execution Environment](rdoc-ref:Process@Execution+Environment).
   #
+  # Argument `options` is a hash of options for the new process; see [Execution
+  # Options](rdoc-ref:Process@Execution+Options).
   #
-  # In the first form, the string is taken as a command line that is subject to
-  # shell expansion before being executed.
+  # The first required argument is one of the following:
   #
-  # The standard shell always means `"/bin/sh"` on Unix-like systems, otherwise,
-  # `ENV["RUBYSHELL"]` or `ENV["COMSPEC"]` on Windows and similar.  The command is
-  # passed as an argument to the `"-c"` switch to the shell, except in the case of
-  # `COMSPEC`.
+  # *   `command_line` if it is a string, and if it begins with a shell reserved
+  #     word or special built-in, or if it contains one or more meta characters.
+  # *   `exe_path` otherwise.
   #
-  # If the string from the first form (`exec("command")`) follows these simple
-  # rules:
+  # **Argument `command_line`**
   #
-  # *   no meta characters
-  # *   not starting with shell reserved word or special built-in
-  # *   Ruby invokes the command directly without shell
+  # String argument `command_line` is a command line to be passed to a shell; it
+  # must begin with a shell reserved word, begin with a special built-in, or
+  # contain meta characters:
   #
+  #     exec('if true; then echo "Foo"; fi') # Shell reserved word.
+  #     exec('exit')                         # Built-in.
+  #     exec('date > date.tmp')              # Contains meta character.
   #
-  # You can force shell invocation by adding ";" to the string (because ";" is a
-  # meta character).
+  # The command line may also contain arguments and options for the command:
   #
-  # Note that this behavior is observable by pid obtained (return value of spawn()
-  # and IO#pid for IO.popen) is the pid of the invoked command, not shell.
+  #     exec('echo "Foo"')
   #
-  # In the second form (`exec("command1", "arg1", ...)`), the first is taken as a
-  # command name and the rest are passed as parameters to command with no shell
-  # expansion.
+  # Output:
   #
-  # In the third form (`exec(["command", "argv0"], "arg1", ...)`), starting a
-  # two-element array at the beginning of the command, the first element is the
-  # command to be executed, and the second argument is used as the `argv[0]`
-  # value, which may show up in process listings.
+  #     Foo
   #
-  # In order to execute the command, one of the `exec(2)` system calls are used,
-  # so the running command may inherit some of the environment of the original
-  # program (including open file descriptors).
+  # See [Execution Shell](rdoc-ref:Process@Execution+Shell) for details about the
+  # shell.
   #
-  # This behavior is modified by the given `env` and `options` parameters. See
-  # ::spawn for details.
+  # Raises an exception if the new process could not execute.
   #
-  # If the command fails to execute (typically Errno::ENOENT when it was not
-  # found) a SystemCallError exception is raised.
+  # **Argument `exe_path`**
   #
-  # This method modifies process attributes according to given `options` before
-  # `exec(2)` system call. See ::spawn for more details about the given `options`.
+  # Argument `exe_path` is one of the following:
   #
-  # The modified attributes may be retained when `exec(2)` system call fails.
+  # *   The string path to an executable to be called.
+  # *   A 2-element array containing the path to an executable and the string to
+  #     be used as the name of the executing process.
   #
-  # For example, hard resource limits are not restorable.
+  # Example:
   #
-  # Consider to create a child process using ::spawn or Kernel#system if this is
-  # not acceptable.
+  #     exec('/usr/bin/date')
   #
-  #     exec "echo *"       # echoes list of files in current directory
-  #     # never get here
+  # Output:
   #
-  #     exec "echo", "*"    # echoes an asterisk
-  #     # never get here
+  #     Sat Aug 26 09:38:00 AM CDT 2023
   #
-  def self?.exec: (*String args) -> bot
+  # Ruby invokes the executable directly. This form does not use the shell; see
+  # [Arguments args](rdoc-ref:Process@Arguments+args) for caveats.
+  #
+  #     exec('doesnt_exist') # Raises Errno::ENOENT
+  #
+  # If one or more `args` is given, each is an argument or option to be passed to
+  # the executable:
+  #
+  #     exec('echo', 'C*')
+  #     exec('echo', 'hello', 'world')
+  #
+  # Output:
+  #
+  #     C*
+  #     hello world
+  #
+  # Raises an exception if the new process could not execute.
+  #
+  def self?.exec: (String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> bot
+                | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> bot
 
   type redirect_fd = Integer | :in | :out | :err | IO | String | [ String ] | [ String, string | int ] | [ String, string | int, int ] | [ :child, int ] | :close
 
   # <!--
   #   rdoc-file=process.c
-  #   - spawn([env,] command... [,options])     -> pid
-  #   - Process.spawn([env,] command... [,options])     -> pid
-  # -->
-  # spawn executes specified command and return its pid.
-  #
-  #     pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
-  #     Process.wait pid
-  #
-  #     pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
-  #     Process.wait pid
-  #
-  # This method is similar to Kernel#system but it doesn't wait for the command to
-  # finish.
-  #
-  # The parent process should use Process.wait to collect the termination status
-  # of its child or use Process.detach to register disinterest in their status;
-  # otherwise, the operating system may accumulate zombie processes.
-  #
-  # spawn has bunch of options to specify process attributes:
-  #
-  #     env: hash
-  #       name => val : set the environment variable
-  #       name => nil : unset the environment variable
-  #
-  #       the keys and the values except for +nil+ must be strings.
-  #     command...:
-  #       commandline                 : command line string which is passed to the standard shell
-  #       cmdname, arg1, ...          : command name and one or more arguments (This form does not use the shell. See below for caveats.)
-  #       [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
-  #     options: hash
-  #       clearing environment variables:
-  #         :unsetenv_others => true   : clear environment variables except specified by env
-  #         :unsetenv_others => false  : don't clear (default)
-  #       process group:
-  #         :pgroup => true or 0 : make a new process group
-  #         :pgroup => pgid      : join the specified process group
-  #         :pgroup => nil       : don't change the process group (default)
-  #       create new process group: Windows only
-  #         :new_pgroup => true  : the new process is the root process of a new process group
-  #         :new_pgroup => false : don't create a new process group (default)
-  #       resource limit: resourcename is core, cpu, data, etc.  See Process.setrlimit.
-  #         :rlimit_resourcename => limit
-  #         :rlimit_resourcename => [cur_limit, max_limit]
-  #       umask:
-  #         :umask => int
-  #       redirection:
-  #         key:
-  #           FD              : single file descriptor in child process
-  #           [FD, FD, ...]   : multiple file descriptor in child process
-  #         value:
-  #           FD                        : redirect to the file descriptor in parent process
-  #           string                    : redirect to file with open(string, "r" or "w")
-  #           [string]                  : redirect to file with open(string, File::RDONLY)
-  #           [string, open_mode]       : redirect to file with open(string, open_mode, 0644)
-  #           [string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
-  #           [:child, FD]              : redirect to the redirected file descriptor
-  #           :close                    : close the file descriptor in child process
-  #         FD is one of follows
-  #           :in     : the file descriptor 0 which is the standard input
-  #           :out    : the file descriptor 1 which is the standard output
-  #           :err    : the file descriptor 2 which is the standard error
-  #           integer : the file descriptor of specified the integer
-  #           io      : the file descriptor specified as io.fileno
-  #       file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
-  #         :close_others => false  : inherit
-  #       current directory:
-  #         :chdir => str
-  #
-  # The `cmdname, arg1, ...` form does not use the shell. However, on different
-  # OSes, different things are provided as built-in commands. An example of this
-  # is +'echo'+, which is a built-in on Windows, but is a normal program on Linux
-  # and Mac OS X. This means that `Process.spawn 'echo', '%Path%'` will display
-  # the contents of the `%Path%` environment variable on Windows, but
-  # `Process.spawn 'echo', '$PATH'` prints the literal `$PATH`.
-  #
-  # If a hash is given as `env`, the environment is updated by `env` before
-  # `exec(2)` in the child process. If a pair in `env` has nil as the value, the
-  # variable is deleted.
-  #
-  #     # set FOO as BAR and unset BAZ.
-  #     pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command)
-  #
-  # If a hash is given as `options`, it specifies process group, create new
-  # process group, resource limit, current directory, umask and redirects for the
-  # child process. Also, it can be specified to clear environment variables.
-  #
-  # The `:unsetenv_others` key in `options` specifies to clear environment
-  # variables, other than specified by `env`.
-  #
-  #     pid = spawn(command, :unsetenv_others=>true) # no environment variable
-  #     pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only
-  #
-  # The `:pgroup` key in `options` specifies a process group. The corresponding
-  # value should be true, zero, a positive integer, or nil. true and zero cause
-  # the process to be a process leader of a new process group. A non-zero positive
-  # integer causes the process to join the provided process group. The default
-  # value, nil, causes the process to remain in the same process group.
-  #
-  #     pid = spawn(command, :pgroup=>true) # process leader
-  #     pid = spawn(command, :pgroup=>10) # belongs to the process group 10
-  #
-  # The `:new_pgroup` key in `options` specifies to pass
-  # `CREATE_NEW_PROCESS_GROUP` flag to `CreateProcessW()` that is Windows API.
-  # This option is only for Windows. true means the new process is the root
-  # process of the new process group. The new process has CTRL+C disabled. This
-  # flag is necessary for `Process.kill(:SIGINT, pid)` on the subprocess.
-  # :new_pgroup is false by default.
-  #
-  #     pid = spawn(command, :new_pgroup=>true)  # new process group
-  #     pid = spawn(command, :new_pgroup=>false) # same process group
-  #
-  # The `:rlimit_`*foo* key specifies a resource limit. *foo* should be one of
-  # resource types such as `core`. The corresponding value should be an integer or
-  # an array which have one or two integers: same as cur_limit and max_limit
-  # arguments for Process.setrlimit.
-  #
-  #     cur, max = Process.getrlimit(:CORE)
-  #     pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary.
-  #     pid = spawn(command, :rlimit_core=>max) # enable core dump
-  #     pid = spawn(command, :rlimit_core=>0) # never dump core.
-  #
-  # The `:umask` key in `options` specifies the umask.
-  #
-  #     pid = spawn(command, :umask=>077)
-  #
-  # The :in, :out, :err, an integer, an IO and an array key specifies a
-  # redirection. The redirection maps a file descriptor in the child process.
-  #
-  # For example, stderr can be merged into stdout as follows:
-  #
-  #     pid = spawn(command, :err=>:out)
-  #     pid = spawn(command, 2=>1)
-  #     pid = spawn(command, STDERR=>:out)
-  #     pid = spawn(command, STDERR=>STDOUT)
-  #
-  # The hash keys specifies a file descriptor in the child process started by
-  # #spawn. :err, 2 and STDERR specifies the standard error stream (stderr).
-  #
-  # The hash values specifies a file descriptor in the parent process which
-  # invokes #spawn. :out, 1 and STDOUT specifies the standard output stream
-  # (stdout).
-  #
-  # In the above example, the standard output in the child process is not
-  # specified. So it is inherited from the parent process.
+  #   - spawn([env, ] command_line, options = {}) -> pid
+  #   - spawn([env, ] exe_path, *args, options  = {}) -> pid
+  # -->
+  # Creates a new child process by doing one of the following in that process:
+  #
+  # *   Passing string `command_line` to the shell.
+  # *   Invoking the executable at `exe_path`.
   #
-  # The standard input stream (stdin) can be specified by :in, 0 and STDIN.
+  # This method has potential security vulnerabilities if called with untrusted
+  # input; see [Command Injection](rdoc-ref:command_injection.rdoc).
   #
-  # A filename can be specified as a hash value.
+  # Returns the process ID (pid) of the new process, without waiting for it to
+  # complete.
   #
-  #     pid = spawn(command, :in=>"/dev/null") # read mode
-  #     pid = spawn(command, :out=>"/dev/null") # write mode
-  #     pid = spawn(command, :err=>"log") # write mode
-  #     pid = spawn(command, [:out, :err]=>"/dev/null") # write mode
-  #     pid = spawn(command, 3=>"/dev/null") # read mode
+  # To avoid zombie processes, the parent process should call either:
   #
-  # For stdout and stderr (and combination of them), it is opened in write mode.
-  # Otherwise read mode is used.
+  # *   Process.wait, to collect the termination statuses of its children.
+  # *   Process.detach, to register disinterest in their status.
   #
-  # For specifying flags and permission of file creation explicitly, an array is
-  # used instead.
+  # The new process is created using the [exec system
+  # call](https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/e
+  # xecve.html); it may inherit some of its environment from the calling program
+  # (possibly including open file descriptors).
   #
-  #     pid = spawn(command, :in=>["file"]) # read mode is assumed
-  #     pid = spawn(command, :in=>["file", "r"])
-  #     pid = spawn(command, :out=>["log", "w"]) # 0644 assumed
-  #     pid = spawn(command, :out=>["log", "w", 0600])
-  #     pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])
+  # Argument `env`, if given, is a hash that affects `ENV` for the new process;
+  # see [Execution Environment](rdoc-ref:Process@Execution+Environment).
   #
-  # The array specifies a filename, flags and permission. The flags can be a
-  # string or an integer. If the flags is omitted or nil, File::RDONLY is assumed.
-  # The permission should be an integer. If the permission is omitted or nil, 0644
-  # is assumed.
+  # Argument `options` is a hash of options for the new process; see [Execution
+  # Options](rdoc-ref:Process@Execution+Options).
   #
-  # If an array of IOs and integers are specified as a hash key, all the elements
-  # are redirected.
+  # The first required argument is one of the following:
   #
-  #     # stdout and stderr is redirected to log file.
-  #     # The file "log" is opened just once.
-  #     pid = spawn(command, [:out, :err]=>["log", "w"])
+  # *   `command_line` if it is a string, and if it begins with a shell reserved
+  #     word or special built-in, or if it contains one or more meta characters.
+  # *   `exe_path` otherwise.
   #
-  # Another way to merge multiple file descriptors is [:child, fd]. [:child, fd]
-  # means the file descriptor in the child process. This is different from fd. For
-  # example, :err=>:out means redirecting child stderr to parent stdout. But
-  # :err=>[:child, :out] means redirecting child stderr to child stdout. They
-  # differ if stdout is redirected in the child process as follows.
+  # **Argument `command_line`**
   #
-  #     # stdout and stderr is redirected to log file.
-  #     # The file "log" is opened just once.
-  #     pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out])
+  # String argument `command_line` is a command line to be passed to a shell; it
+  # must begin with a shell reserved word, begin with a special built-in, or
+  # contain meta characters:
   #
-  # [:child, :out] can be used to merge stderr into stdout in IO.popen. In this
-  # case, IO.popen redirects stdout to a pipe in the child process and [:child,
-  # :out] refers the redirected stdout.
+  #     spawn('if true; then echo "Foo"; fi') # => 798847 # Shell reserved word.
+  #     Process.wait                          # => 798847
+  #     spawn('exit')                         # => 798848 # Built-in.
+  #     Process.wait                          # => 798848
+  #     spawn('date > /tmp/date.tmp')         # => 798879 # Contains meta character.
+  #     Process.wait                          # => 798849
+  #     spawn('date > /nop/date.tmp')         # => 798882 # Issues error message.
+  #     Process.wait                          # => 798882
   #
-  #     io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]])
-  #     p io.read #=> "out\nerr\n"
+  # The command line may also contain arguments and options for the command:
   #
-  # The `:chdir` key in `options` specifies the current directory.
+  #     spawn('echo "Foo"') # => 799031
+  #     Process.wait        # => 799031
   #
-  #     pid = spawn(command, :chdir=>"/var/tmp")
+  # Output:
   #
-  # spawn closes all non-standard unspecified descriptors by default. The
-  # "standard" descriptors are 0, 1 and 2. This behavior is specified by
-  # :close_others option. :close_others doesn't affect the standard descriptors
-  # which are closed only if :close is specified explicitly.
+  #     Foo
   #
-  #     pid = spawn(command, :close_others=>true)  # close 3,4,5,... (default)
-  #     pid = spawn(command, :close_others=>false) # don't close 3,4,5,...
+  # See [Execution Shell](rdoc-ref:Process@Execution+Shell) for details about the
+  # shell.
   #
-  # :close_others is false by default for spawn and IO.popen.
+  # Raises an exception if the new process could not execute.
   #
-  # Note that fds which close-on-exec flag is already set are closed regardless of
-  # :close_others option.
+  # **Argument `exe_path`**
   #
-  # So IO.pipe and spawn can be used as IO.popen.
+  # Argument `exe_path` is one of the following:
   #
-  #     # similar to r = IO.popen(command)
-  #     r, w = IO.pipe
-  #     pid = spawn(command, :out=>w)   # r, w is closed in the child process.
-  #     w.close
+  # *   The string path to an executable to be called.
+  # *   A 2-element array containing the path to an executable to be called, and
+  #     the string to be used as the name of the executing process.
   #
-  # :close is specified as a hash value to close a fd individually.
+  #         spawn('/usr/bin/date') # Path to date on Unix-style system.
+  #         Process.wait
   #
-  #     f = open(foo)
-  #     system(command, f=>:close)        # don't inherit f.
+  #     Output:
   #
-  # If a file descriptor need to be inherited, io=>io can be used.
+  #         Mon Aug 28 11:43:10 AM CDT 2023
   #
-  #     # valgrind has --log-fd option for log destination.
-  #     # log_w=>log_w indicates log_w.fileno inherits to child process.
-  #     log_r, log_w = IO.pipe
-  #     pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
-  #     log_w.close
-  #     p log_r.read
+  # Ruby invokes the executable directly. This form does not use the shell; see
+  # [Arguments args](rdoc-ref:Process@Arguments+args) for caveats.
   #
-  # It is also possible to exchange file descriptors.
+  # If one or more `args` is given, each is an argument or option to be passed to
+  # the executable:
   #
-  #     pid = spawn(command, :out=>:err, :err=>:out)
+  #     spawn('echo', 'C*')             # => 799392
+  #     Process.wait                    # => 799392
+  #     spawn('echo', 'hello', 'world') # => 799393
+  #     Process.wait                    # => 799393
   #
-  # The hash keys specify file descriptors in the child process. The hash values
-  # specifies file descriptors in the parent process. So the above specifies
-  # exchanging stdout and stderr. Internally, `spawn` uses an extra file
-  # descriptor to resolve such cyclic file descriptor mapping.
+  # Output:
   #
-  # See Kernel.exec for the standard shell.
+  #     C*
+  #     hello world
+  #
+  # Raises an exception if the new process could not execute.
   #
   def self?.spawn: (String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> Integer
                  | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> Integer
 
   # <!--
   #   rdoc-file=process.c
-  #   - system([env,] command... [,options], exception: false)    -> true, false or nil
+  #   - system([env, ] command_line, options = {}, exception: false) -> true, false, or nil
+  #   - system([env, ] exe_path, *args, options  = {}, exception: false) -> true, false, or nil
+  # -->
+  # Creates a new child process by doing one of the following in that process:
+  #
+  # *   Passing string `command_line` to the shell.
+  # *   Invoking the executable at `exe_path`.
+  #
+  # This method has potential security vulnerabilities if called with untrusted
+  # input; see [Command Injection](rdoc-ref:command_injection.rdoc).
+  #
+  # Returns:
+  #
+  # *   `true` if the command exits with status zero.
+  # *   `false` if the exit status is a non-zero integer.
+  # *   `nil` if the command could not execute.
+  #
+  # Raises an exception (instead of returning `false` or `nil`) if keyword
+  # argument `exception` is set to `true`.
+  #
+  # Assigns the command's error status to `$?`.
+  #
+  # The new process is created using the [system system
+  # call](https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/s
+  # ystem.html); it may inherit some of its environment from the calling program
+  # (possibly including open file descriptors).
+  #
+  # Argument `env`, if given, is a hash that affects `ENV` for the new process;
+  # see [Execution Environment](rdoc-ref:Process@Execution+Environment).
+  #
+  # Argument `options` is a hash of options for the new process; see [Execution
+  # Options](rdoc-ref:Process@Execution+Options).
+  #
+  # The first required argument is one of the following:
+  #
+  # *   `command_line` if it is a string, and if it begins with a shell reserved
+  #     word or special built-in, or if it contains one or more meta characters.
+  # *   `exe_path` otherwise.
+  #
+  # **Argument `command_line`**
+  #
+  # String argument `command_line` is a command line to be passed to a shell; it
+  # must begin with a shell reserved word, begin with a special built-in, or
+  # contain meta characters:
+  #
+  #     system('if true; then echo "Foo"; fi')          # => true  # Shell reserved word.
+  #     system('exit')                                  # => true  # Built-in.
+  #     system('date > /tmp/date.tmp')                  # => true  # Contains meta character.
+  #     system('date > /nop/date.tmp')                  # => false
+  #     system('date > /nop/date.tmp', exception: true) # Raises RuntimeError.
+  #
+  # Assigns the command's error status to `$?`:
+  #
+  #     system('exit')                             # => true  # Built-in.
+  #     $?                                         # => #<Process::Status: pid 640610 exit 0>
+  #     system('date > /nop/date.tmp')             # => false
+  #     $?                                         # => #<Process::Status: pid 640742 exit 2>
+  #
+  # The command line may also contain arguments and options for the command:
+  #
+  #     system('echo "Foo"') # => true
+  #
+  # Output:
+  #
+  #     Foo
+  #
+  # See [Execution Shell](rdoc-ref:Process@Execution+Shell) for details about the
+  # shell.
+  #
+  # Raises an exception if the new process could not execute.
+  #
+  # **Argument `exe_path`**
+  #
+  # Argument `exe_path` is one of the following:
+  #
+  # *   The string path to an executable to be called.
+  # *   A 2-element array containing the path to an executable and the string to
+  #     be used as the name of the executing process.
+  #
+  # Example:
+  #
+  #     system('/usr/bin/date') # => true # Path to date on Unix-style system.
+  #     system('foo')           # => nil  # Command failed.
+  #
+  # Output:
+  #
+  #     Mon Aug 28 11:43:10 AM CDT 2023
+  #
+  # Assigns the command's error status to `$?`:
+  #
+  #     system('/usr/bin/date') # => true
+  #     $?                      # => #<Process::Status: pid 645605 exit 0>
+  #     system('foo')           # => nil
+  #     $?                      # => #<Process::Status: pid 645608 exit 127>
+  #
+  # Ruby invokes the executable directly. This form does not use the shell; see
+  # [Arguments args](rdoc-ref:Process@Arguments+args) for caveats.
+  #
+  #     system('doesnt_exist') # => nil
+  #
+  # If one or more `args` is given, each is an argument or option to be passed to
+  # the executable:
+  #
+  #     system('echo', 'C*')             # => true
+  #     system('echo', 'hello', 'world') # => true
+  #
+  # Output:
+  #
+  #     C*
+  #     hello world
+  #
+  # Raises an exception if the new process could not execute.
+  #
+  def self?.system: (String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String, ?exception: bool) -> (NilClass | FalseClass | TrueClass)
+                  | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String, ?exception: bool) -> (NilClass | FalseClass | TrueClass)
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj !~ other  -> true or false
+  # -->
+  # Returns true if two objects do not match (using the *=~* method), otherwise
+  # false.
+  #
+  def !~: (untyped other) -> bool
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj <=> other -> 0 or nil
+  # -->
+  # Returns 0 if `obj` and `other` are the same object or `obj == other`,
+  # otherwise nil.
+  #
+  # The #<=> is used by various methods to compare objects, for example
+  # Enumerable#sort, Enumerable#max etc.
+  #
+  # Your implementation of #<=> should return one of the following values: -1, 0,
+  # 1 or nil. -1 means self is smaller than other. 0 means self is equal to other.
+  # 1 means self is bigger than other. Nil means the two values could not be
+  # compared.
+  #
+  # When you define #<=>, you can include Comparable to gain the methods #<=, #<,
+  # #==, #>=, #> and #between?.
+  #
+  def <=>: (untyped other) -> 0?
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj === other   -> true or false
+  # -->
+  # Case Equality -- For class Object, effectively the same as calling `#==`, but
+  # typically overridden by descendants to provide meaningful semantics in `case`
+  # statements.
+  #
+  alias === ==
+
+  # <!--
+  #   rdoc-file=kernel.rb
+  #   - obj.clone(freeze: nil) -> an_object
+  # -->
+  # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
+  # but not the objects they reference. #clone copies the frozen value state of
+  # *obj*, unless the `:freeze` keyword argument is given with a false or true
+  # value. See also the discussion under Object#dup.
+  #
+  #     class Klass
+  #        attr_accessor :str
+  #     end
+  #     s1 = Klass.new      #=> #<Klass:0x401b3a38>
+  #     s1.str = "Hello"    #=> "Hello"
+  #     s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
+  #     s2.str[1,4] = "i"   #=> "i"
+  #     s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
+  #     s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
+  #
+  # This method may have class-specific behavior. If so, that behavior will be
+  # documented under the #`initialize_copy` method of the class.
+  #
+  def clone: (?freeze: bool?) -> self
+
+  # <!--
+  #   rdoc-file=proc.c
+  #   - define_singleton_method(symbol, method) -> symbol
+  #   - define_singleton_method(symbol) { block } -> symbol
+  # -->
+  # Defines a public singleton method in the receiver. The *method* parameter can
+  # be a `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified,
+  # it is used as the method body. If a block or a method has parameters, they're
+  # used as method parameters.
+  #
+  #     class A
+  #       class << self
+  #         def class_name
+  #           to_s
+  #         end
+  #       end
+  #     end
+  #     A.define_singleton_method(:who_am_i) do
+  #       "I am: #{class_name}"
+  #     end
+  #     A.who_am_i   # ==> "I am: A"
+  #
+  #     guy = "Bob"
+  #     guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
+  #     guy.hello    #=>  "Bob: Hello there!"
+  #
+  #     chris = "Chris"
+  #     chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
+  #     chris.greet("Hi") #=> "Hi, I'm Chris!"
+  #
+  def define_singleton_method: (interned name, Method | UnboundMethod | Proc method) -> Symbol
+                             | (interned name) { (?) -> untyped } -> Symbol
+
+  # <!--
+  #   rdoc-file=io.c
+  #   - display(port = $>) -> nil
+  # -->
+  # Writes `self` on the given port:
+  #
+  #     1.display
+  #     "cat".display
+  #     [ 4, 5, 6 ].display
+  #     puts
+  #
+  # Output:
+  #
+  #     1cat[4, 5, 6]
+  #
+  def display: (?_Writer port) -> nil
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.dup -> an_object
+  # -->
+  # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
+  # but not the objects they reference.
+  #
+  # This method may have class-specific behavior.  If so, that behavior will be
+  # documented under the #`initialize_copy` method of the class.
+  #
+  # ### on dup vs clone
+  #
+  # In general, #clone and #dup may have different semantics in descendant
+  # classes. While #clone is used to duplicate an object, including its internal
+  # state, #dup typically uses the class of the descendant object to create the
+  # new instance.
+  #
+  # When using #dup, any modules that the object has been extended with will not
+  # be copied.
+  #
+  #     class Klass
+  #       attr_accessor :str
+  #     end
+  #
+  #     module Foo
+  #       def foo; 'foo'; end
+  #     end
+  #
+  #     s1 = Klass.new #=> #<Klass:0x401b3a38>
+  #     s1.extend(Foo) #=> #<Klass:0x401b3a38>
+  #     s1.foo #=> "foo"
+  #
+  #     s2 = s1.clone #=> #<Klass:0x401be280>
+  #     s2.foo #=> "foo"
+  #
+  #     s3 = s1.dup #=> #<Klass:0x401c1084>
+  #     s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>
+  #
+  def dup: () -> self
+
+  # <!-- rdoc-file=enumerator.c -->
+  # Creates a new Enumerator which will enumerate by calling `method` on `obj`,
+  # passing `args` if any. What was *yielded* by method becomes values of
+  # enumerator.
+  #
+  # If a block is given, it will be used to calculate the size of the enumerator
+  # without the need to iterate it (see Enumerator#size).
+  #
+  # ### Examples
+  #
+  #     str = "xyz"
+  #
+  #     enum = str.enum_for(:each_byte)
+  #     enum.each { |b| puts b }
+  #     # => 120
+  #     # => 121
+  #     # => 122
+  #
+  #     # protect an array from being modified by some_method
+  #     a = [1, 2, 3]
+  #     some_method(a.to_enum)
+  #
+  #     # String#split in block form is more memory-effective:
+  #     very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
+  #     # This could be rewritten more idiomatically with to_enum:
+  #     very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first
+  #
+  # It is typical to call to_enum when defining methods for a generic Enumerable,
+  # in case no block is passed.
+  #
+  # Here is such an example, with parameter passing and a sizing block:
+  #
+  #     module Enumerable
+  #       # a generic method to repeat the values of any enumerable
+  #       def repeat(n)
+  #         raise ArgumentError, "#{n} is negative!" if n < 0
+  #         unless block_given?
+  #           return to_enum(__method__, n) do # __method__ is :repeat here
+  #             sz = size     # Call size and multiply by n...
+  #             sz * n if sz  # but return nil if size itself is nil
+  #           end
+  #         end
+  #         each do |*val|
+  #           n.times { yield *val }
+  #         end
+  #       end
+  #     end
+  #
+  #     %i[hello world].repeat(2) { |w| puts w }
+  #       # => Prints 'hello', 'hello', 'world', 'world'
+  #     enum = (1..14).repeat(3)
+  #       # => returns an Enumerator when called without a block
+  #     enum.first(4) # => [1, 1, 1, 2]
+  #     enum.size # => 42
+  #
+  def enum_for: (?interned method, *untyped, **untyped) ?{ (*untyped, **untyped) -> Integer } -> Enumerator[untyped, untyped]
+
+  alias to_enum enum_for
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj == other        -> true or false
+  #   - obj.equal?(other)   -> true or false
+  #   - obj.eql?(other)     -> true or false
   # -->
-  # Executes *command...* in a subshell. *command...* is one of following forms.
+  # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
+  # are the same object.  Typically, this method is overridden in descendant
+  # classes to provide class-specific meaning.
   #
-  # `commandline`
-  # :   command line string which is passed to the standard shell
-  # `cmdname, arg1, ...`
-  # :   command name and one or more arguments (no shell)
-  # `[cmdname, argv0], arg1, ...`
-  # :   command name, `argv[0]` and zero or more arguments (no shell)
+  # Unlike #==, the #equal? method should never be overridden by subclasses as it
+  # is used to determine object identity (that is, `a.equal?(b)` if and only if
+  # `a` is the same object as `b`):
   #
+  #     obj = "a"
+  #     other = obj.dup
   #
-  # system returns `true` if the command gives zero exit status, `false` for non
-  # zero exit status. Returns `nil` if command execution fails. An error status is
-  # available in `$?`.
+  #     obj == other      #=> true
+  #     obj.equal? other  #=> false
+  #     obj.equal? obj    #=> true
   #
-  # If the `exception: true` argument is passed, the method raises an exception
-  # instead of returning `false` or `nil`.
+  # The #eql? method returns `true` if `obj` and `other` refer to the same hash
+  # key.  This is used by Hash to test members for equality.  For any pair of
+  # objects where #eql? returns `true`, the #hash value of both objects must be
+  # equal. So any subclass that overrides #eql? should also override #hash
+  # appropriately.
   #
-  # The arguments are processed in the same way as for Kernel#spawn.
+  # For objects of class Object, #eql?  is synonymous with #==.  Subclasses
+  # normally continue this tradition by aliasing #eql? to their overridden #==
+  # method, but there are exceptions. Numeric types, for example, perform type
+  # conversion across #==, but not across #eql?, so:
   #
-  # The hash arguments, env and options, are same as #exec and #spawn. See
-  # Kernel#spawn for details.
+  #     1 == 1.0     #=> true
+  #     1.eql? 1.0   #=> false
   #
-  #     system("echo *")
-  #     system("echo", "*")
+  def eql?: (untyped other) -> bool
+
+  # <!--
+  #   rdoc-file=eval.c
+  #   - obj.extend(module, ...)    -> obj
+  # -->
+  # Adds to *obj* the instance methods from each module given as a parameter.
+  #
+  #     module Mod
+  #       def hello
+  #         "Hello from Mod.\n"
+  #       end
+  #     end
+  #
+  #     class Klass
+  #       def hello
+  #         "Hello from Klass.\n"
+  #       end
+  #     end
+  #
+  #     k = Klass.new
+  #     k.hello         #=> "Hello from Klass.\n"
+  #     k.extend(Mod)   #=> #<Klass:0x401b3bc8>
+  #     k.hello         #=> "Hello from Mod.\n"
+  #
+  def extend: (Module module, *Module other_modules) -> self
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.freeze    -> obj
+  # -->
+  # Prevents further modifications to *obj*. A FrozenError will be raised if
+  # modification is attempted. There is no way to unfreeze a frozen object. See
+  # also Object#frozen?.
+  #
+  # This method returns self.
+  #
+  #     a = [ "a", "b", "c" ]
+  #     a.freeze
+  #     a << "z"
   #
   # *produces:*
   #
-  #     config.h main.rb
-  #     *
+  #     prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
+  #      from prog.rb:3
+  #
+  # Objects of the following classes are always frozen: Integer, Float, Symbol.
+  #
+  def freeze: () -> self
+
+  # <!--
+  #   rdoc-file=kernel.rb
+  #   - obj.frozen?    -> true or false
+  # -->
+  # Returns the freeze status of *obj*.
+  #
+  #     a = [ "a", "b", "c" ]
+  #     a.freeze    #=> ["a", "b", "c"]
+  #     a.frozen?   #=> true
   #
-  # Error handling:
+  def frozen?: () -> bool
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.hash    -> integer
+  # -->
+  # Generates an Integer hash value for this object.  This function must have the
+  # property that `a.eql?(b)` implies `a.hash == b.hash`.
   #
-  #     system("cat nonexistent.txt")
-  #     # => false
-  #     system("catt nonexistent.txt")
-  #     # => nil
+  # The hash value is used along with #eql? by the Hash class to determine if two
+  # objects reference the same hash key.  Any hash value that exceeds the capacity
+  # of an Integer will be truncated before being used.
   #
-  #     system("cat nonexistent.txt", exception: true)
-  #     # RuntimeError (Command failed with exit 1: cat)
-  #     system("catt nonexistent.txt", exception: true)
-  #     # Errno::ENOENT (No such file or directory - catt)
+  # The hash value for an object may not be identical across invocations or
+  # implementations of Ruby.  If you need a stable identifier across Ruby
+  # invocations and implementations you will need to generate one with a custom
+  # method.
   #
-  # See Kernel#exec for the standard shell.
+  # Certain core classes such as Integer use built-in hash calculations and do not
+  # call the #hash method when used as a hash key.
   #
-  def self?.system: (String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> (NilClass | FalseClass | TrueClass)
-                  | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> (NilClass | FalseClass | TrueClass)
-end
+  # When implementing your own #hash based on multiple values, the best practice
+  # is to combine the class and any values using the hash code of an array:
+  #
+  # For example:
+  #
+  #     def hash
+  #       [self.class, a, b, c].hash
+  #     end
+  #
+  # The reason for this is that the Array#hash method already has logic for safely
+  # and efficiently combining multiple hash values.
+  #
+  def hash: () -> Integer
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.inspect   -> string
+  # -->
+  # Returns a string containing a human-readable representation of *obj*. The
+  # default #inspect shows the object's class name, an encoding of its memory
+  # address, and a list of the instance variables and their values (by calling
+  # #inspect on each of them).  User defined classes should override this method
+  # to provide a better representation of *obj*.  When overriding this method, it
+  # should return a string whose encoding is compatible with the default external
+  # encoding.
+  #
+  #     [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
+  #     Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"
+  #
+  #     class Foo
+  #     end
+  #     Foo.new.inspect                  #=> "#<Foo:0x0300c868>"
+  #
+  #     class Bar
+  #       def initialize
+  #         @bar = 1
+  #       end
+  #     end
+  #     Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"
+  #
+  def inspect: () -> String
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.instance_of?(class)    -> true or false
+  # -->
+  # Returns `true` if *obj* is an instance of the given class. See also
+  # Object#kind_of?.
+  #
+  #     class A;     end
+  #     class B < A; end
+  #     class C < B; end
+  #
+  #     b = B.new
+  #     b.instance_of? A   #=> false
+  #     b.instance_of? B   #=> true
+  #     b.instance_of? C   #=> false
+  #
+  def instance_of?: (Module | Class module_or_class) -> bool
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.instance_variable_defined?(symbol)    -> true or false
+  #   - obj.instance_variable_defined?(string)    -> true or false
+  # -->
+  # Returns `true` if the given instance variable is defined in *obj*. String
+  # arguments are converted to symbols.
+  #
+  #     class Fred
+  #       def initialize(p1, p2)
+  #         @a, @b = p1, p2
+  #       end
+  #     end
+  #     fred = Fred.new('cat', 99)
+  #     fred.instance_variable_defined?(:@a)    #=> true
+  #     fred.instance_variable_defined?("@b")   #=> true
+  #     fred.instance_variable_defined?("@c")   #=> false
+  #
+  def instance_variable_defined?: (interned variable) -> bool
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.instance_variable_get(symbol)    -> obj
+  #   - obj.instance_variable_get(string)    -> obj
+  # -->
+  # Returns the value of the given instance variable, or nil if the instance
+  # variable is not set. The `@` part of the variable name should be included for
+  # regular instance variables. Throws a NameError exception if the supplied
+  # symbol is not valid as an instance variable name. String arguments are
+  # converted to symbols.
+  #
+  #     class Fred
+  #       def initialize(p1, p2)
+  #         @a, @b = p1, p2
+  #       end
+  #     end
+  #     fred = Fred.new('cat', 99)
+  #     fred.instance_variable_get(:@a)    #=> "cat"
+  #     fred.instance_variable_get("@b")   #=> 99
+  #
+  def instance_variable_get: (interned variable) -> untyped
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.instance_variable_set(symbol, obj)    -> obj
+  #   - obj.instance_variable_set(string, obj)    -> obj
+  # -->
+  # Sets the instance variable named by *symbol* to the given object. This may
+  # circumvent the encapsulation intended by the author of the class, so it should
+  # be used with care. The variable does not have to exist prior to this call. If
+  # the instance variable name is passed as a string, that string is converted to
+  # a symbol.
+  #
+  #     class Fred
+  #       def initialize(p1, p2)
+  #         @a, @b = p1, p2
+  #       end
+  #     end
+  #     fred = Fred.new('cat', 99)
+  #     fred.instance_variable_set(:@a, 'dog')   #=> "dog"
+  #     fred.instance_variable_set(:@c, 'cat')   #=> "cat"
+  #     fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
+  #
+  def instance_variable_set: [T] (interned variable, T value) -> T
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.instance_variables    -> array
+  # -->
+  # Returns an array of instance variable names for the receiver. Note that simply
+  # defining an accessor does not create the corresponding instance variable.
+  #
+  #     class Fred
+  #       attr_accessor :a1
+  #       def initialize
+  #         @iv = 3
+  #       end
+  #     end
+  #     Fred.new.instance_variables   #=> [:@iv]
+  #
+  def instance_variables: () -> Array[Symbol]
+
+  # <!-- rdoc-file=object.c -->
+  # Returns `true` if *class* is the class of *obj*, or if *class* is one of the
+  # superclasses of *obj* or modules included in *obj*.
+  #
+  #     module M;    end
+  #     class A
+  #       include M
+  #     end
+  #     class B < A; end
+  #     class C < B; end
+  #
+  #     b = B.new
+  #     b.is_a? A          #=> true
+  #     b.is_a? B          #=> true
+  #     b.is_a? C          #=> false
+  #     b.is_a? M          #=> true
+  #
+  #     b.kind_of? A       #=> true
+  #     b.kind_of? B       #=> true
+  #     b.kind_of? C       #=> false
+  #     b.kind_of? M       #=> true
+  #
+  def is_a?: (Module | Class module_or_class) -> bool
+
+  alias kind_of? is_a?
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.itself    -> obj
+  # -->
+  # Returns the receiver.
+  #
+  #     string = "my string"
+  #     string.itself.object_id == string.object_id   #=> true
+  #
+  def itself: () -> self
+
+  # <!--
+  #   rdoc-file=proc.c
+  #   - obj.method(sym)    -> method
+  # -->
+  # Looks up the named method as a receiver in *obj*, returning a Method object
+  # (or raising NameError). The Method object acts as a closure in *obj*'s object
+  # instance, so instance variables and the value of `self` remain available.
+  #
+  #     class Demo
+  #       def initialize(n)
+  #         @iv = n
+  #       end
+  #       def hello()
+  #         "Hello, @iv = #{@iv}"
+  #       end
+  #     end
+  #
+  #     k = Demo.new(99)
+  #     m = k.method(:hello)
+  #     m.call   #=> "Hello, @iv = 99"
+  #
+  #     l = Demo.new('Fred')
+  #     m = l.method("hello")
+  #     m.call   #=> "Hello, @iv = Fred"
+  #
+  # Note that Method implements `to_proc` method, which means it can be used with
+  # iterators.
+  #
+  #     [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout
+  #
+  #     out = File.open('test.txt', 'w')
+  #     [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file
+  #
+  #     require 'date'
+  #     %w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
+  #     #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]
+  #
+  def method: (interned name) -> Method
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.methods(regular=true)    -> array
+  # -->
+  # Returns a list of the names of public and protected methods of *obj*. This
+  # will include all the methods accessible in *obj*'s ancestors. If the optional
+  # parameter is `false`, it returns an array of *obj*'s public and protected
+  # singleton methods, the array will not include methods in modules included in
+  # *obj*.
+  #
+  #     class Klass
+  #       def klass_method()
+  #       end
+  #     end
+  #     k = Klass.new
+  #     k.methods[0..9]    #=> [:klass_method, :nil?, :===,
+  #                        #    :==~, :!, :eql?
+  #                        #    :hash, :<=>, :class, :singleton_class]
+  #     k.methods.length   #=> 56
+  #
+  #     k.methods(false)   #=> []
+  #     def k.singleton_method; end
+  #     k.methods(false)   #=> [:singleton_method]
+  #
+  #     module M123; def m123; end end
+  #     k.extend M123
+  #     k.methods(false)   #=> [:singleton_method]
+  #
+  def methods: (?boolish regular) -> Array[Symbol]
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.nil?               -> true or false
+  # -->
+  # Only the object *nil* responds `true` to `nil?`.
+  #
+  #     Object.new.nil?   #=> false
+  #     nil.nil?          #=> true
+  #
+  def nil?: () -> false
+
+  # <!--
+  #   rdoc-file=gc.c
+  #   - obj.__id__       -> integer
+  #   - obj.object_id    -> integer
+  # -->
+  # Returns an integer identifier for `obj`.
+  #
+  # The same number will be returned on all calls to `object_id` for a given
+  # object, and no two active objects will share an id.
+  #
+  # Note: that some objects of builtin classes are reused for optimization. This
+  # is the case for immediate values and frozen string literals.
+  #
+  # BasicObject implements +__id__+, Kernel implements `object_id`.
+  #
+  # Immediate values are not passed by reference but are passed by value: `nil`,
+  # `true`, `false`, Fixnums, Symbols, and some Floats.
+  #
+  #     Object.new.object_id  == Object.new.object_id  # => false
+  #     (21 * 2).object_id    == (21 * 2).object_id    # => true
+  #     "hello".object_id     == "hello".object_id     # => false
+  #     "hi".freeze.object_id == "hi".freeze.object_id # => true
+  #
+  alias object_id __id__
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.private_methods(all=true)   -> array
+  # -->
+  # Returns the list of private methods accessible to *obj*. If the *all*
+  # parameter is set to `false`, only those methods in the receiver will be
+  # listed.
+  #
+  def private_methods: (?boolish all) -> Array[Symbol]
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.protected_methods(all=true)   -> array
+  # -->
+  # Returns the list of protected methods accessible to *obj*. If the *all*
+  # parameter is set to `false`, only those methods in the receiver will be
+  # listed.
+  #
+  def protected_methods: (?boolish all) -> Array[Symbol]
 
-Kernel::RUBYGEMS_ACTIVATION_MONITOR: untyped
+  # <!--
+  #   rdoc-file=proc.c
+  #   - obj.public_method(sym)    -> method
+  # -->
+  # Similar to *method*, searches public method only.
+  #
+  def public_method: (interned name) -> Method
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.public_methods(all=true)   -> array
+  # -->
+  # Returns the list of public methods accessible to *obj*. If the *all* parameter
+  # is set to `false`, only those methods in the receiver will be listed.
+  #
+  def public_methods: (?boolish all) -> Array[Symbol]
+
+  # <!--
+  #   rdoc-file=vm_eval.c
+  #   - obj.public_send(symbol [, args...])  -> obj
+  #   - obj.public_send(string [, args...])  -> obj
+  # -->
+  # Invokes the method identified by *symbol*, passing it any arguments specified.
+  # Unlike send, public_send calls public methods only. When the method is
+  # identified by a string, the string is converted to a symbol.
+  #
+  #     1.public_send(:puts, "hello")  # causes NoMethodError
+  #
+  def public_send: (interned name, *untyped, **untyped) ?{ (?) -> untyped } -> untyped
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.remove_instance_variable(symbol)    -> obj
+  #   - obj.remove_instance_variable(string)    -> obj
+  # -->
+  # Removes the named instance variable from *obj*, returning that variable's
+  # value. String arguments are converted to symbols.
+  #
+  #     class Dummy
+  #       attr_reader :var
+  #       def initialize
+  #         @var = 99
+  #       end
+  #       def remove
+  #         remove_instance_variable(:@var)
+  #       end
+  #     end
+  #     d = Dummy.new
+  #     d.var      #=> 99
+  #     d.remove   #=> 99
+  #     d.var      #=> nil
+  #
+  def remove_instance_variable: (interned variable) -> untyped
+
+  # <!--
+  #   rdoc-file=vm_method.c
+  #   - obj.respond_to?(symbol, include_all=false) -> true or false
+  #   - obj.respond_to?(string, include_all=false) -> true or false
+  # -->
+  # Returns `true` if *obj* responds to the given method.  Private and protected
+  # methods are included in the search only if the optional second parameter
+  # evaluates to `true`.
+  #
+  # If the method is not implemented, as Process.fork on Windows, File.lchmod on
+  # GNU/Linux, etc., false is returned.
+  #
+  # If the method is not defined, `respond_to_missing?` method is called and the
+  # result is returned.
+  #
+  # When the method name parameter is given as a string, the string is converted
+  # to a symbol.
+  #
+  def respond_to?: (interned name, ?boolish include_all) -> bool
+
+  # <!--
+  #   rdoc-file=vm_method.c
+  #   - obj.respond_to_missing?(symbol, include_all) -> true or false
+  #   - obj.respond_to_missing?(string, include_all) -> true or false
+  # -->
+  # DO NOT USE THIS DIRECTLY.
+  #
+  # Hook method to return whether the *obj* can respond to *id* method or not.
+  #
+  # When the method name parameter is given as a string, the string is converted
+  # to a symbol.
+  #
+  # See #respond_to?, and the example of BasicObject.
+  #
+  private def respond_to_missing?: (Symbol | String name, bool include_all) -> bool
+
+  # <!--
+  #   rdoc-file=vm_eval.c
+  #   - foo.send(symbol [, args...])       -> obj
+  #   - foo.__send__(symbol [, args...])   -> obj
+  #   - foo.send(string [, args...])       -> obj
+  #   - foo.__send__(string [, args...])   -> obj
+  # -->
+  # Invokes the method identified by *symbol*, passing it any arguments specified.
+  # When the method is identified by a string, the string is converted to a
+  # symbol.
+  #
+  # BasicObject implements +__send__+, Kernel implements `send`. `__send__` is
+  # safer than `send` when *obj* has the same method name like `Socket`. See also
+  # `public_send`.
+  #
+  #     class Klass
+  #       def hello(*args)
+  #         "Hello " + args.join(' ')
+  #       end
+  #     end
+  #     k = Klass.new
+  #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
+  #
+  alias send __send__
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.singleton_class    -> class
+  # -->
+  # Returns the singleton class of *obj*.  This method creates a new singleton
+  # class if *obj* does not have one.
+  #
+  # If *obj* is `nil`, `true`, or `false`, it returns NilClass, TrueClass, or
+  # FalseClass, respectively. If *obj* is an Integer, a Float or a Symbol, it
+  # raises a TypeError.
+  #
+  #     Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
+  #     String.singleton_class      #=> #<Class:String>
+  #     nil.singleton_class         #=> NilClass
+  #
+  def singleton_class: () -> Class
+
+  # <!--
+  #   rdoc-file=proc.c
+  #   - obj.singleton_method(sym)    -> method
+  # -->
+  # Similar to *method*, searches singleton method only.
+  #
+  #     class Demo
+  #       def initialize(n)
+  #         @iv = n
+  #       end
+  #       def hello()
+  #         "Hello, @iv = #{@iv}"
+  #       end
+  #     end
+  #
+  #     k = Demo.new(99)
+  #     def k.hi
+  #       "Hi, @iv = #{@iv}"
+  #     end
+  #     m = k.singleton_method(:hi)
+  #     m.call   #=> "Hi, @iv = 99"
+  #     m = k.singleton_method(:hello) #=> NameError
+  #
+  def singleton_method: (interned name) -> Method
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.singleton_methods(all=true)    -> array
+  # -->
+  # Returns an array of the names of singleton methods for *obj*. If the optional
+  # *all* parameter is true, the list will include methods in modules included in
+  # *obj*. Only public and protected singleton methods are returned.
+  #
+  #     module Other
+  #       def three() end
+  #     end
+  #
+  #     class Single
+  #       def Single.four() end
+  #     end
+  #
+  #     a = Single.new
+  #
+  #     def a.one()
+  #     end
+  #
+  #     class << a
+  #       include Other
+  #       def two()
+  #       end
+  #     end
+  #
+  #     Single.singleton_methods    #=> [:four]
+  #     a.singleton_methods(false)  #=> [:two, :one]
+  #     a.singleton_methods         #=> [:two, :one, :three]
+  #
+  def singleton_methods: (?boolish all) -> Array[Symbol]
+
+  # <!--
+  #   rdoc-file=kernel.rb
+  #   - obj.tap {|x| block }    -> obj
+  # -->
+  # Yields self to the block and then returns self. The primary purpose of this
+  # method is to "tap into" a method chain, in order to perform operations on
+  # intermediate results within the chain.
+  #
+  #     (1..10)                  .tap {|x| puts "original: #{x}" }
+  #       .to_a                  .tap {|x| puts "array:    #{x}" }
+  #       .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }
+  #       .map {|x| x*x }        .tap {|x| puts "squares:  #{x}" }
+  #
+  def tap: () { (self) -> void } -> self
+
+  # <!--
+  #   rdoc-file=object.c
+  #   - obj.to_s    -> string
+  # -->
+  # Returns a string representing *obj*. The default #to_s prints the object's
+  # class and an encoding of the object id. As a special case, the top-level
+  # object that is the initial execution context of Ruby programs returns
+  # ``main''.
+  #
+  def to_s: () -> String
+
+  # <!--
+  #   rdoc-file=kernel.rb
+  #   - yield_self()
+  # -->
+  #
+  def yield_self: () -> Enumerator[self, untyped]
+                | [T] () { (self) -> T } -> T
+
+  # <!--
+  #   rdoc-file=kernel.rb
+  #   - obj.then {|x| block }          -> an_object
+  # -->
+  # Yields self to the block and returns the result of the block.
+  #
+  #     3.next.then {|x| x**x }.to_s             #=> "256"
+  #
+  # A good use of `then` is value piping in method chains:
+  #
+  #     require 'open-uri'
+  #     require 'json'
+  #
+  #     construct_url(arguments)
+  #       .then {|url| URI(url).read }
+  #       .then {|response| JSON.parse(response) }
+  #
+  # When called without a block, the method returns an `Enumerator`, which can be
+  # used, for example, for conditional circuit-breaking:
+  #
+  #     # Meets condition, no-op
+  #     1.then.detect(&:odd?)            # => 1
+  #     # Does not meet condition, drop value
+  #     2.then.detect(&:odd?)            # => nil
+  #
+  alias then yield_self
+
+  private
+
+  def initialize_copy: (self object) -> self
+
+  def initialize_clone: (self object, ?freeze: bool?) -> self
+
+  def initialize_dup: (self object) -> self
+end