rbs 0.13.1 → 0.14.0

data/stdlib/builtin/signal.rbs

@@ -3,7 +3,7 @@
 # trapped at the code level and acted upon. For example, your process may
 # trap the USR1 signal and use it to toggle debugging, and may use TERM to
 # initiate a controlled shutdown.
-# 
+#
 # ```ruby
 # pid = fork do
 #   Signal.trap("USR1") do
@@ -16,9 +16,9 @@
 #   end
 #   # . . . do some work . . .
 # end
-# 
+#
 # Process.detach(pid)
-# 
+#
 # # Controlling program:
 # Process.kill("USR1", pid)
 # # ...
@@ -26,15 +26,15 @@
 # # ...
 # Process.kill("TERM", pid)
 # ```
-# 
+#
 # produces:
-# 
+#
 # ```
 #  Debug now: true
 #  Debug now: false
 # Terminating...
 # ```
-# 
+#
 # The list of available signal names and their interpretation is system
 # dependent. [Signal](Signal) delivery semantics may
 # also vary between systems; in particular signal delivery may not always
@@ -42,7 +42,7 @@
 module Signal
   # Returns a list of signal names mapped to the corresponding underlying
   # signal numbers.
-  # 
+  #
   # ```ruby
   # Signal.list   #=> {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "IOT"=>6, "ABRT"=>6, "FPE"=>8, "KILL"=>9, "BUS"=>7, "SEGV"=>11, "SYS"=>31, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>23, "STOP"=>19, "TSTP"=>20, "CONT"=>18, "CHLD"=>17, "CLD"=>17, "TTIN"=>21, "TTOU"=>22, "IO"=>29, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "USR1"=>10, "USR2"=>12, "PWR"=>30, "POLL"=>29}
   # ```

data/stdlib/builtin/string.rbs

@@ -456,7 +456,7 @@ class String
   #
   # *   On some OSes such as Mac OS, `crypt(3)` is not thread safe.
   #
-  # *   So-called "traditional" usage of `crypt(3)` is very very very weak. 
+  # *   So-called "traditional" usage of `crypt(3)` is very very very weak.
   #     According to its manpage, Linux's traditional `crypt(3)` output has only
   #     2**56 variations; too easy to brute force today.  And this is the default
   #     behaviour.
@@ -735,7 +735,7 @@ class String
   # :   Sets the replacement string to the given value. The default replacement
   #     string is "uFFFD" for Unicode encoding forms, and "?" otherwise.
   # :fallback
-  # :   Sets the replacement string by the given object for undefined character. 
+  # :   Sets the replacement string by the given object for undefined character.
   #     The object should be a Hash, a Proc, a Method, or an object which has []
   #     method. Its key is an undefined character encoded in the source encoding
   #     of current transcoder. Its value can be any encoding until it can be
@@ -1532,7 +1532,7 @@ class String
   #
   def to_i: (?int base) -> Integer
 
-  # Returns the result of interpreting leading characters in `str` as a rational. 
+  # Returns the result of interpreting leading characters in `str` as a rational.
   # Leading whitespace and extraneous characters past the end of a valid number
   # are ignored. Digit sequences can be separated by an underscore. If there is
   # not a valid number at the start of `str`, zero is returned.  This method never
@@ -1806,7 +1806,7 @@ class String
   # In that case data would be lost but often it's the case that the array only
   # holds one value, especially when unpacking binary data. For instance:
   #
-  # "xffx00x00x00".unpack("l")         #=>  [255] "xffx00x00x00".unpack1("l")     
+  # "xffx00x00x00".unpack("l")         #=>  [255] "xffx00x00x00".unpack1("l")
   #   #=>  255
   #
   # Thus unpack1 is convenient, makes clear the intention and signals the expected

data/stdlib/builtin/string_io.rbs

@@ -114,7 +114,7 @@ class StringIO
   #
   def gets: (?String sep, ?Integer limit, ?chomp: bool) -> String?
 
-  # Returns the Encoding of the internal string if conversion is specified. 
+  # Returns the Encoding of the internal string if conversion is specified.
   # Otherwise returns `nil`.
   #
   def internal_encoding: () -> Encoding

data/stdlib/builtin/thread.rbs

@@ -1,43 +1,43 @@
 # Threads are the Ruby implementation for a concurrent programming model.
-# 
+#
 # Programs that require multiple threads of execution are a perfect
 # candidate for Ruby's [Thread](Thread) class.
-# 
+#
 # For example, we can create a new thread separate from the main thread's
 # execution using [::new](Thread#method-c-new).
-# 
+#
 # ```ruby
 # thr = Thread.new { puts "Whats the big deal" }
 # ```
-# 
+#
 # Then we are able to pause the execution of the main thread and allow our
 # new thread to finish, using
 # [join](Thread#method-i-join):
-# 
+#
 # ```ruby
 # thr.join #=> "Whats the big deal"
 # ```
-# 
+#
 # If we don't call `thr.join` before the main thread terminates, then all
 # other threads including `thr` will be killed.
-# 
+#
 # Alternatively, you can use an array for handling multiple threads at
 # once, like in the following example:
-# 
+#
 # ```ruby
 # threads = []
 # threads << Thread.new { puts "Whats the big deal" }
 # threads << Thread.new { 3.times { puts "Threads are fun!" } }
 # ```
-# 
+#
 # After creating a few threads we wait for them all to finish
 # consecutively.
-# 
+#
 # ```ruby
 # threads.each { |thr| thr.join }
 # ```
-# 
-# 
+#
+#
 # In order to create new threads, Ruby provides
 # [::new](Thread#method-c-new),
 # [::start](Thread#method-c-start), and
@@ -45,59 +45,59 @@
 # provided with each of these methods, otherwise a
 # [ThreadError](https://ruby-doc.org/core-2.6.3/ThreadError.html) will be
 # raised.
-# 
+#
 # When subclassing the [Thread](Thread) class, the
 # `initialize` method of your subclass will be ignored by
 # [::start](Thread#method-c-start) and
 # [::fork](Thread#method-c-fork). Otherwise, be sure
 # to call super in your `initialize` method.
-# 
-# 
+#
+#
 # For terminating threads, Ruby provides a variety of ways to do this.
-# 
+#
 # The class method [::kill](Thread#method-c-kill), is
 # meant to exit a given thread:
-# 
+#
 #     thr = Thread.new { ... }
 #     Thread.kill(thr) # sends exit() to thr
-# 
+#
 # Alternatively, you can use the instance method
 # [exit](Thread#method-i-exit), or any of its aliases
 # [kill](Thread#method-i-kill) or
 # [terminate](Thread#method-i-terminate).
-# 
+#
 # ```ruby
 # thr.exit
 # ```
-# 
-# 
+#
+#
 # Ruby provides a few instance methods for querying the state of a given
 # thread. To get a string with the current thread's state use
 # [status](Thread#method-i-status)
-# 
+#
 # ```ruby
 # thr = Thread.new { sleep }
 # thr.status # => "sleep"
 # thr.exit
 # thr.status # => false
 # ```
-# 
+#
 # You can also use [alive?](Thread#method-i-alive-3F)
 # to tell if the thread is running or sleeping, and
 # [stop?](Thread#method-i-stop-3F) if the thread is
 # dead or sleeping.
-# 
-# 
+#
+#
 # Since threads are created with blocks, the same rules apply to other
 # Ruby blocks for variable scope. Any local variables created within this
 # block are accessible to only this thread.
-# 
-# 
+#
+#
 # Each fiber has its own bucket for
 # [\#\[\]](Thread#method-i-5B-5D) storage. When you
 # set a new fiber-local it is only accessible within this
 # [Fiber](https://ruby-doc.org/core-2.6.3/Fiber.html). To illustrate:
-# 
+#
 # ```ruby
 # Thread.new {
 #   Thread.current[:foo] = "bar"
@@ -106,7 +106,7 @@
 #   }.resume
 # }.join
 # ```
-# 
+#
 # This example uses [\[\]](Thread#method-i-5B-5D) for
 # getting and [\[\]=](Thread#method-i-5B-5D-3D) for
 # setting fiber-locals, you can also use
@@ -114,10 +114,10 @@
 # fiber-locals for a given thread and
 # [key?](Thread#method-i-key-3F) to check if a
 # fiber-local exists.
-# 
+#
 # When it comes to thread-locals, they are accessible within the entire
 # scope of the thread. Given the following example:
-# 
+#
 # ```ruby
 # Thread.new{
 #   Thread.current.thread_variable_set(:foo, 1)
@@ -129,29 +129,29 @@
 #   p Thread.current.thread_variable_get(:foo)   # => 2
 # }.join
 # ```
-# 
+#
 # You can see that the thread-local `:foo` carried over into the fiber and
 # was changed to `2` by the end of the thread.
-# 
+#
 # This example makes use of
 # [thread\_variable\_set](Thread#method-i-thread_variable_set)
 # to create new thread-locals, and
 # [thread\_variable\_get](Thread#method-i-thread_variable_get)
 # to reference them.
-# 
+#
 # There is also
 # [thread\_variables](Thread#method-i-thread_variables)
 # to list all thread-locals, and
 # [thread\_variable?](Thread#method-i-thread_variable-3F)
 # to check if a given thread-local exists.
-# 
-# 
+#
+#
 # Any thread can raise an exception using the
 # [raise](Thread#method-i-raise) instance method,
 # which operates similarly to
 # [Kernel\#raise](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-raise)
 # .
-# 
+#
 # However, it's important to note that an exception that occurs in any
 # thread except the main thread depends on
 # [abort\_on\_exception](Thread#method-i-abort_on_exception)
@@ -162,22 +162,22 @@
 # default by either
 # [abort\_on\_exception=](Thread#method-i-abort_on_exception-3D)
 # `true` or setting $DEBUG to `true` .
-# 
+#
 # With the addition of the class method
 # [::handle\_interrupt](Thread#method-c-handle_interrupt)
 # , you can now handle exceptions asynchronously with threads.
-# 
-# 
+#
+#
 # Ruby provides a few ways to support scheduling threads in your program.
-# 
+#
 # The first way is by using the class method
 # [::stop](Thread#method-c-stop), to put the current
 # running thread to sleep and schedule the execution of another thread.
-# 
+#
 # Once a thread is asleep, you can use the instance method
 # [wakeup](Thread#method-i-wakeup) to mark your thread
 # as eligible for scheduling.
-# 
+#
 # You can also try [::pass](Thread#method-c-pass),
 # which attempts to pass execution to another thread but is dependent on
 # the OS whether a running thread will switch or not. The same goes for
@@ -195,9 +195,9 @@ class Thread < Object
 
   # Attribute Assignment—Sets or creates the value of a fiber-local
   # variable, using either a symbol or a string.
-  # 
+  #
   # See also [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D).
-  # 
+  #
   # For thread-local variables, please see
   # [thread\_variable\_set](Thread.downloaded.ruby_doc#method-i-thread_variable_set)
   # and
@@ -208,23 +208,23 @@ class Thread < Object
   def alive?: () -> bool
 
   # Terminates `thr` and schedules another thread to be run.
-  # 
+  #
   # If this thread is already marked to be killed,
   # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
   # [Thread](Thread.downloaded.ruby_doc).
-  # 
+  #
   # If this is the main thread, or the last thread, exits the process.
   def kill: () -> Thread?
 
   # Returns the status of the thread-local “abort on exception” condition
   # for this `thr` .
-  # 
+  #
   # The default is `false` .
-  # 
+  #
   # See also
   # [abort\_on\_exception=](Thread.downloaded.ruby_doc#method-i-abort_on_exception-3D)
   # .
-  # 
+  #
   # There is also a class level method to set this for all threads, see
   # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
   # .
@@ -232,18 +232,18 @@ class Thread < Object
 
   # When set to `true`, if this `thr` is aborted by an exception, the
   # raised exception will be re-raised in the main thread.
-  # 
+  #
   # See also
   # [abort\_on\_exception](Thread.downloaded.ruby_doc#method-i-abort_on_exception)
   # .
-  # 
+  #
   # There is also a class level method to set this for all threads, see
   # [::abort\_on\_exception=](Thread.downloaded.ruby_doc#method-c-abort_on_exception-3D)
   # .
   def abort_on_exception=: (bool abort_on_exception) -> untyped
 
   # Adds *proc* as a handler for tracing.
-  # 
+  #
   # See
   # [\#set\_trace\_func](Thread.downloaded.ruby_doc#method-i-set_trace_func)
   # and
@@ -256,22 +256,22 @@ class Thread < Object
 
   # Returns the execution stack for the target thread—an array containing
   # backtrace location objects.
-  # 
+  #
   # See
   # [Thread::Backtrace::Location](https://ruby-doc.org/core-2.6.3/Thread/Backtrace/Location.html)
   # for more information.
-  # 
+  #
   # This method behaves similarly to
   # [Kernel\#caller\_locations](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-caller_locations)
   # except it applies to a specific thread.
   def backtrace_locations: (*untyped args) -> ::Array[untyped]?
 
   # Terminates `thr` and schedules another thread to be run.
-  # 
+  #
   # If this thread is already marked to be killed,
   # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
   # [Thread](Thread.downloaded.ruby_doc).
-  # 
+  #
   # If this is the main thread, or the last thread, exits the process.
   def exit: () -> Thread?
 
@@ -290,36 +290,36 @@ class Thread < Object
   def initialize: (*untyped args) -> Thread
 
   # The calling thread will suspend execution and run this `thr` .
-  # 
+  #
   # Does not return until `thr` exits or until the given `limit` seconds
   # have passed.
-  # 
+  #
   # If the time limit expires, `nil` will be returned, otherwise `thr` is
   # returned.
-  # 
+  #
   # Any threads not joined will be killed when the main program exits.
-  # 
+  #
   # If `thr` had previously raised an exception and the
   # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
   # or $DEBUG flags are not set, (so the exception has not yet been
   # processed), it will be processed at this time.
-  # 
+  #
   # ```ruby
   # a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
   # x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
   # x.join # Let thread x finish, thread a will be killed on exit.
   # #=> "axyz"
   # ```
-  # 
+  #
   # The following example illustrates the `limit` parameter.
-  # 
+  #
   # ```ruby
   # y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}
   # puts "Waiting" until y.join(0.15)
   # ```
-  # 
+  #
   # This will produce:
-  # 
+  #
   #     tick...
   #     Waiting
   #     tick...
@@ -330,7 +330,7 @@ class Thread < Object
 
   # Returns `true` if the given string (or symbol) exists as a fiber-local
   # variable.
-  # 
+  #
   # ```ruby
   # me = Thread.current
   # me[:oliver] = "a"
@@ -350,9 +350,9 @@ class Thread < Object
 
   # Returns whether or not the asynchronous queue is empty for the target
   # thread.
-  # 
+  #
   # If `error` is given, then check only for `error` type deferred events.
-  # 
+  #
   # See
   # [::pending\_interrupt?](Thread.downloaded.ruby_doc#method-c-pending_interrupt-3F)
   # for more information.
@@ -362,10 +362,10 @@ class Thread < Object
   # thread which creating the new thread, or zero for the initial main
   # thread; higher-priority thread will run more frequently than
   # lower-priority threads (but lower-priority threads can also run).
-  # 
+  #
   # This is just hint for Ruby thread scheduler. It may be ignored on some
   # platform.
-  # 
+  #
   # ```ruby
   # Thread.current.priority   #=> 0
   # ```
@@ -374,17 +374,17 @@ class Thread < Object
   # Sets the priority of *thr* to *integer* . Higher-priority threads will
   # run more frequently than lower-priority threads (but lower-priority
   # threads can also run).
-  # 
+  #
   # This is just hint for Ruby thread scheduler. It may be ignored on some
   # platform.
-  # 
+  #
   # ```ruby
   # count1 = count2 = 0
   # a = Thread.new do
   #       loop { count1 += 1 }
   #     end
   # a.priority = -1
-  # 
+  #
   # b = Thread.new do
   #       loop { count2 += 1 }
   #     end
@@ -397,16 +397,16 @@ class Thread < Object
 
   # Returns the status of the thread-local “report on exception” condition
   # for this `thr` .
-  # 
+  #
   # The default value when creating a [Thread](Thread.downloaded.ruby_doc)
   # is the value of the global flag
   # [::report\_on\_exception](Thread.downloaded.ruby_doc#method-c-report_on_exception)
   # .
-  # 
+  #
   # See also
   # [report\_on\_exception=](Thread.downloaded.ruby_doc#method-i-report_on_exception-3D)
   # .
-  # 
+  #
   # There is also a class level method to set this for all new threads, see
   # [::report\_on\_exception=](Thread.downloaded.ruby_doc#method-c-report_on_exception-3D)
   # .
@@ -416,18 +416,18 @@ class Thread < Object
   # kills this `thr` . See
   # [::report\_on\_exception](Thread.downloaded.ruby_doc#method-c-report_on_exception)
   # for details.
-  # 
+  #
   # See also
   # [report\_on\_exception](Thread.downloaded.ruby_doc#method-i-report_on_exception)
   # .
-  # 
+  #
   # There is also a class level method to set this for all new threads, see
   # [::report\_on\_exception=](Thread.downloaded.ruby_doc#method-c-report_on_exception-3D)
   # .
   def report_on_exception=: (bool report_on_exception) -> untyped
 
   # Wakes up `thr`, making it eligible for scheduling.
-  # 
+  #
   # ```ruby
   # a = Thread.new { puts "a"; Thread.stop; puts "c" }
   # sleep 0.1 while a.status!='sleep'
@@ -435,21 +435,21 @@ class Thread < Object
   # a.run
   # a.join
   # ```
-  # 
+  #
   # This will produce:
-  # 
+  #
   # ```ruby
   # a
   # Got here
   # c
   # ```
-  # 
+  #
   # See also the instance method
   # [wakeup](Thread.downloaded.ruby_doc#method-i-wakeup).
   def run: () -> Thread
 
   # Returns the safe level.
-  # 
+  #
   # This method is obsolete because $SAFE is a process global state. Simply
   # check $SAFE.
   def safe_level: () -> Integer
@@ -457,37 +457,37 @@ class Thread < Object
   def status: () -> (String | bool)?
 
   # Returns `true` if `thr` is dead or sleeping.
-  # 
+  #
   # ```ruby
   # a = Thread.new { Thread.stop }
   # b = Thread.current
   # a.stop?   #=> true
   # b.stop?   #=> false
   # ```
-  # 
+  #
   # See also [alive?](Thread.downloaded.ruby_doc#method-i-alive-3F) and
   # [status](Thread.downloaded.ruby_doc#method-i-status).
   def `stop?`: () -> bool
 
   # Terminates `thr` and schedules another thread to be run.
-  # 
+  #
   # If this thread is already marked to be killed,
   # [exit](Thread.downloaded.ruby_doc#method-i-exit) returns the
   # [Thread](Thread.downloaded.ruby_doc).
-  # 
+  #
   # If this is the main thread, or the last thread, exits the process.
   def terminate: () -> Thread?
 
   # Returns `true` if the given string (or symbol) exists as a thread-local
   # variable.
-  # 
+  #
   # ```ruby
   # me = Thread.current
   # me.thread_variable_set(:oliver, "a")
   # me.thread_variable?(:oliver)    #=> true
   # me.thread_variable?(:stanley)   #=> false
   # ```
-  # 
+  #
   # Note that these are not fiber local variables. Please see
   # [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D) and
   # [\#thread\_variable\_get](Thread.downloaded.ruby_doc#method-i-thread_variable_get)
@@ -498,15 +498,15 @@ class Thread < Object
   # that these are different than fiber local values. For fiber local
   # values, please see [\#\[\]](Thread.downloaded.ruby_doc#method-i-5B-5D)
   # and [\#\[\]=](Thread.downloaded.ruby_doc#method-i-5B-5D-3D).
-  # 
+  #
   # [Thread](Thread.downloaded.ruby_doc) local values are carried along with
   # threads, and do not respect fibers. For example:
-  # 
+  #
   # ```ruby
   # Thread.new {
   #   Thread.current.thread_variable_set("foo", "bar") # set a thread local
   #   Thread.current["foo"] = "bar"                    # set a fiber local
-  # 
+  #
   #   Fiber.new {
   #     Fiber.yield [
   #       Thread.current.thread_variable_get("foo"), # get the thread local
@@ -515,7 +515,7 @@ class Thread < Object
   #   }.resume
   # }.join.value # => ['bar', nil]
   # ```
-  # 
+  #
   # The value “bar” is returned for the thread local, where nil is returned
   # for the fiber local. The fiber is executed in the same thread, so the
   # thread local values are available.
@@ -533,11 +533,11 @@ class Thread < Object
   # Waits for `thr` to complete, using
   # [join](Thread.downloaded.ruby_doc#method-i-join), and returns its value
   # or raises the exception which terminated the thread.
-  # 
+  #
   # ```ruby
   # a = Thread.new { 2 + 2 }
   # a.value   #=> 4
-  # 
+  #
   # b = Thread.new { raise 'something went wrong' }
   # b.value   #=> RuntimeError: something went wrong
   # ```
@@ -545,10 +545,10 @@ class Thread < Object
 
   # Marks a given thread as eligible for scheduling, however it may still
   # remain blocked on I/O.
-  # 
+  #
   # **Note:** This does not invoke the scheduler, see
   # [run](Thread.downloaded.ruby_doc#method-i-run) for more information.
-  # 
+  #
   # ```ruby
   # c = Thread.new { Thread.stop; puts "hey!" }
   # sleep 0.1 while c.status!='sleep'
@@ -559,19 +559,19 @@ class Thread < Object
   def wakeup: () -> Thread
 
   # Returns the status of the global “abort on exception” condition.
-  # 
+  #
   # The default is `false` .
-  # 
+  #
   # When set to `true`, if any thread is aborted by an exception, the
   # raised exception will be re-raised in the main thread.
-  # 
+  #
   # Can also be specified by the global $DEBUG flag or command line option
   # `-d` .
-  # 
+  #
   # See also
   # [::abort\_on\_exception=](Thread.downloaded.ruby_doc#method-c-abort_on_exception-3D)
   # .
-  # 
+  #
   # There is also an instance level method to set this for a specific
   # thread, see
   # [abort\_on\_exception](Thread.downloaded.ruby_doc#method-i-abort_on_exception)
@@ -581,7 +581,7 @@ class Thread < Object
   # When set to `true`, if any thread is aborted by an exception, the
   # raised exception will be re-raised in the main thread. Returns the new
   # state.
-  # 
+  #
   # ```ruby
   # Thread.abort_on_exception = true
   # t1 = Thread.new do
@@ -591,19 +591,19 @@ class Thread < Object
   # sleep(1)
   # puts "not reached"
   # ```
-  # 
+  #
   # This will produce:
-  # 
+  #
   #     In new thread
   #     prog.rb:4: Exception from thread (RuntimeError)
   #      from prog.rb:2:in `initialize'
   #      from prog.rb:2:in `new'
   #      from prog.rb:2
-  # 
+  #
   # See also
   # [::abort\_on\_exception](Thread.downloaded.ruby_doc#method-c-abort_on_exception)
   # .
-  # 
+  #
   # There is also an instance level method to set this for a specific
   # thread, see
   # [abort\_on\_exception=](Thread.downloaded.ruby_doc#method-i-abort_on_exception-3D)
@@ -619,11 +619,11 @@ class Thread < Object
 
   # Terminates the currently running thread and schedules another thread to
   # be run.
-  # 
+  #
   # If this thread is already marked to be killed,
   # [::exit](Thread.downloaded.ruby_doc#method-c-exit) returns the
   # [Thread](Thread.downloaded.ruby_doc).
-  # 
+  #
   # If this is the main thread, or the last thread, exit the process.
   def self.exit: () -> untyped
 
@@ -634,46 +634,46 @@ class Thread < Object
   def self.fork: (*untyped args) -> untyped
 
   # Changes asynchronous interrupt timing.
-  # 
+  #
   # *interrupt* means asynchronous event and corresponding procedure by
   # [\#raise](Thread.downloaded.ruby_doc#method-i-raise),
   # [\#kill](Thread.downloaded.ruby_doc#method-i-kill), signal trap (not
   # supported yet) and main thread termination (if main thread terminates,
   # then all other thread will be killed).
-  # 
+  #
   # The given `hash` has pairs like `ExceptionClass => :TimingSymbol` .
   # Where the ExceptionClass is the interrupt handled by the given block.
   # The TimingSymbol can be one of the following symbols:
-  # 
+  #
   #   - `:immediate`
   #     Invoke interrupts immediately.
-  # 
+  #
   #   - `:on_blocking`
   #     Invoke interrupts while *BlockingOperation* .
-  # 
+  #
   #   - `:never`
   #     Never invoke all interrupts.
-  # 
+  #
   # *BlockingOperation* means that the operation will block the calling
   # thread, such as read and write. On CRuby implementation,
   # *BlockingOperation* is any operation executed without GVL.
-  # 
+  #
   # Masked asynchronous interrupts are delayed until they are enabled. This
   # method is similar to sigprocmask(3).
-  # 
-  # 
+  #
+  #
   # Asynchronous interrupts are difficult to use.
-  # 
+  #
   # If you need to communicate between threads, please consider to use
   # another way such as [Queue](https://ruby-doc.org/core-2.6.3/Queue.html)
   # .
-  # 
+  #
   # Or use them with deep understanding about this method.
-  # 
-  # 
+  #
+  #
   # In this example, we can guard from
   # [\#raise](Thread.downloaded.ruby_doc#method-i-raise) exceptions.
-  # 
+  #
   # Using the `:never` TimingSymbol the
   # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
   # exception will always be ignored in the first block of the main thread.
@@ -682,7 +682,7 @@ class Thread < Object
   # block we can purposefully handle
   # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
   # exceptions.
-  # 
+  #
   # ```ruby
   # th = Thread.new do
   #   Thread.handle_interrupt(RuntimeError => :never) {
@@ -700,18 +700,18 @@ class Thread < Object
   # # ...
   # th.raise "stop"
   # ```
-  # 
+  #
   # While we are ignoring the
   # [RuntimeError](https://ruby-doc.org/core-2.6.3/RuntimeError.html)
   # exception, it’s safe to write our resource allocation code. Then, the
   # ensure block is where we can safely deallocate your resources.
-  # 
-  # 
+  #
+  #
   # In the next example, we will guard from the Timeout::Error exception.
   # This will help prevent from leaking resources when Timeout::Error
   # exceptions occur during normal ensure clause. For this example we use
   # the help of the standard library Timeout, from lib/timeout.rb
-  # 
+  #
   # ```ruby
   # require 'timeout'
   # Thread.handle_interrupt(Timeout::Error => :never) {
@@ -725,18 +725,18 @@ class Thread < Object
   #   }
   # }
   # ```
-  # 
+  #
   # In the first part of the `timeout` block, we can rely on Timeout::Error
   # being ignored. Then in the `Timeout::Error => :on_blocking` block, any
   # operation that will block the calling thread is susceptible to a
   # Timeout::Error exception being raised.
-  # 
-  # 
+  #
+  #
   # It’s possible to stack multiple levels of
   # [::handle\_interrupt](Thread.downloaded.ruby_doc#method-c-handle_interrupt)
   # blocks in order to control more than one ExceptionClass and TimingSymbol
   # at a time.
-  # 
+  #
   # ```ruby
   # Thread.handle_interrupt(FooError => :never) {
   #   Thread.handle_interrupt(BarError => :never) {
@@ -744,11 +744,11 @@ class Thread < Object
   #   }
   # }
   # ```
-  # 
-  # 
+  #
+  #
   # All exceptions inherited from the ExceptionClass parameter will be
   # considered.
-  # 
+  #
   # ```ruby
   # Thread.handle_interrupt(Exception => :never) {
   #   # all exceptions inherited from Exception are prohibited.
@@ -765,18 +765,18 @@ class Thread < Object
   def self.pass: () -> untyped
 
   # Returns whether or not the asynchronous queue is empty.
-  # 
+  #
   # Since
   # [::handle\_interrupt](Thread.downloaded.ruby_doc#method-c-handle_interrupt)
   # can be used to defer asynchronous events, this method can be used to
   # determine if there are any deferred events.
-  # 
+  #
   # If you find this method returns true, then you may finish `:never`
   # blocks.
-  # 
+  #
   # For example, the following method processes deferred asynchronous events
   # immediately.
-  # 
+  #
   # ```ruby
   # def Thread.kick_interrupt_immediately
   #   Thread.handle_interrupt(Object => :immediate) {
@@ -784,10 +784,10 @@ class Thread < Object
   #   }
   # end
   # ```
-  # 
+  #
   # If `error` is given, then check only for `error` type deferred events.
-  # 
-  # 
+  #
+  #
   #     th = Thread.new{
   #       Thread.handle_interrupt(RuntimeError => :on_blocking){
   #         while true
@@ -802,10 +802,10 @@ class Thread < Object
   #     }
   #     ...
   #     th.raise # stop thread
-  # 
+  #
   # This example can also be written as the following, which you should use
   # to avoid asynchronous interrupts.
-  # 
+  #
   #     flag = true
   #     th = Thread.new{
   #       Thread.handle_interrupt(RuntimeError => :on_blocking){
@@ -833,7 +833,7 @@ class Thread < Object
 
   # Stops execution of the current thread, putting it into a “sleep” state,
   # and schedules execution of another thread.
-  # 
+  #
   # ```ruby
   # a = Thread.new { print "a"; Thread.stop; print "c" }
   # sleep 0.1 while a.status!='sleep'
@@ -864,13 +864,13 @@ end
 # augment class [Mutex](https://ruby-doc.org/core-2.6.3/Mutex.html).
 # Using condition variables, it is possible to suspend while in the middle
 # of a critical section until a resource becomes available.
-# 
+#
 # Example:
-# 
+#
 # ```ruby
 # mutex = Mutex.new
 # resource = ConditionVariable.new
-# 
+#
 # a = Thread.new {
 #    mutex.synchronize {
 #      # Thread 'a' now needs the resource
@@ -878,7 +878,7 @@ end
 #      # 'a' can now have the resource
 #    }
 # }
-# 
+#
 # b = Thread.new {
 #    mutex.synchronize {
 #      # Thread 'b' has finished using the resource
@@ -895,7 +895,7 @@ class Thread::ConditionVariable < Object
 
   # Releases the lock held in `mutex` and waits; reacquires the lock on
   # wakeup.
-  # 
+  #
   # If `timeout` is given, this method returns after `timeout` seconds
   # passed, even if no other thread doesn't signal.
   def wait: (Thread::Mutex mutex, ?Integer timeout) -> self
@@ -904,18 +904,18 @@ end
 # [Mutex](Mutex) implements a simple semaphore that
 # can be used to coordinate access to shared data from multiple concurrent
 # threads.
-# 
+#
 # Example:
-# 
+#
 # ```ruby
 # semaphore = Mutex.new
-# 
+#
 # a = Thread.new {
 #   semaphore.synchronize {
 #     # access shared resource
 #   }
 # }
-# 
+#
 # b = Thread.new {
 #   semaphore.synchronize {
 #     # access shared resource
@@ -951,15 +951,15 @@ end
 # when information must be exchanged safely between multiple threads. The
 # [Queue](Queue) class implements all the required
 # locking semantics.
-# 
+#
 # The class implements FIFO type of queue. In a FIFO queue, the first
 # tasks added are the first retrieved.
-# 
+#
 # Example:
-# 
+#
 # ```ruby
 # queue = Queue.new
-# 
+#
 # producer = Thread.new do
 #   5.times do |i|
 #      sleep rand(i) # simulate expense
@@ -967,7 +967,7 @@ end
 #      puts "#{i} produced"
 #   end
 # end
-# 
+#
 # consumer = Thread.new do
 #   5.times do |i|
 #      value = queue.pop
@@ -975,7 +975,7 @@ end
 #      puts "consumed #{value}"
 #   end
 # end
-# 
+#
 # consumer.join
 # ```
 class Thread::Queue < Object
@@ -986,28 +986,28 @@ class Thread::Queue < Object
   def clear: () -> void
 
   # Closes the queue. A closed queue cannot be re-opened.
-  # 
+  #
   # After the call to close completes, the following are true:
-  # 
+  #
   #   - `closed?` will return true
-  # 
+  #
   #   - `close` will be ignored.
-  # 
+  #
   #   - calling enq/push/\<\< will raise a `ClosedQueueError` .
-  # 
+  #
   #   - when `empty?` is false, calling deq/pop/shift will return an object
   #     from the queue as usual.
-  # 
+  #
   #   - when `empty?` is true, deq(false) will not suspend the thread and
   #     will return nil. deq(true) will raise a `ThreadError` .
-  # 
+  #
   # [ClosedQueueError](https://ruby-doc.org/core-2.6.3/ClosedQueueError.html)
   # is inherited from
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html), so
   # that you can break loop block.
-  # 
+  #
   #     Example:
-  # 
+  #
   #         q = Queue.new
   #         Thread.new{
   #           while e = q.deq # wait for nil to break loop
@@ -1030,9 +1030,9 @@ class Thread::Queue < Object
   alias enq push
 
   # Returns the length of the queue.
-  # 
-  # 
-  # 
+  #
+  #
+  #
   # Also aliased as: [size](Queue.downloaded.ruby_doc#method-i-size)
   def length: () -> Integer
 
@@ -1040,21 +1040,21 @@ class Thread::Queue < Object
   def num_waiting: () -> Integer
 
   # Retrieves data from the queue.
-  # 
+  #
   # If the queue is empty, the calling thread is suspended until data is
   # pushed onto the queue. If `non_block` is true, the thread isn't
   # suspended, and `ThreadError` is raised.
-  # 
-  # 
-  # 
+  #
+  #
+  #
   # Also aliased as: [deq](Queue.downloaded.ruby_doc#method-i-deq),
   # [shift](Queue.downloaded.ruby_doc#method-i-shift)
   def pop: (?bool non_block) -> untyped
 
   # Pushes the given `object` to the queue.
-  # 
-  # 
-  # 
+  #
+  #
+  #
   # Also aliased as: [enq](Queue.downloaded.ruby_doc#method-i-enq),
   # [\<\<](Queue.downloaded.ruby_doc#method-i-3C-3C)
   def push: (untyped obj) -> void
@@ -1068,7 +1068,7 @@ end
 
 # This class represents queues of specified size capacity. The push
 # operation may be blocked if the capacity is full.
-# 
+#
 # See [Queue](https://ruby-doc.org/core-2.6.3/Queue.html) for an example
 # of how a [SizedQueue](SizedQueue) works.
 class Thread::SizedQueue < Thread::Queue
@@ -1087,13 +1087,13 @@ class Thread::SizedQueue < Thread::Queue
   def max=: (Integer max) -> void
 
   # Pushes `object` to the queue.
-  # 
+  #
   # If there is no space left in the queue, waits until space becomes
   # available, unless `non_block` is true. If `non_block` is true, the
   # thread isn't suspended, and `ThreadError` is raised.
-  # 
-  # 
-  # 
+  #
+  #
+  #
   # Also aliased as: [enq](SizedQueue.downloaded.ruby_doc#method-i-enq),
   # [\<\<](SizedQueue.downloaded.ruby_doc#method-i-3C-3C)
   def push: (untyped obj, ?bool non_block) -> void