rbs 3.4.4 → 3.5.1

data/core/gc.rbs

@@ -7,6 +7,151 @@
 # You may obtain information about the operation of the GC through GC::Profiler.
 #
 module GC
+  # <!-- rdoc-file=gc.c -->
+  # The GC profiler provides access to information on GC runs including time,
+  # length and object space size.
+  #
+  # Example:
+  #
+  #     GC::Profiler.enable
+  #
+  #     require 'rdoc/rdoc'
+  #
+  #     GC::Profiler.report
+  #
+  #     GC::Profiler.disable
+  #
+  # See also GC.count, GC.malloc_allocated_size and GC.malloc_allocations
+  #
+  module Profiler
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.clear          -> nil
+    # -->
+    # Clears the GC profiler data.
+    #
+    def self.clear: () -> nil
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.disable      -> nil
+    # -->
+    # Stops the GC profiler.
+    #
+    def self.disable: () -> nil
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.enable       -> nil
+    # -->
+    # Starts the GC profiler.
+    #
+    def self.enable: () -> nil
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.enabled?     -> true or false
+    # -->
+    # The current status of GC profile mode.
+    #
+    def self.enabled?: () -> bool
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.raw_data    -> [Hash, ...]
+    # -->
+    # Returns an Array of individual raw profile data Hashes ordered from earliest
+    # to latest by `:GC_INVOKE_TIME`.
+    #
+    # For example:
+    #
+    #     [
+    #       {
+    #          :GC_TIME=>1.3000000000000858e-05,
+    #          :GC_INVOKE_TIME=>0.010634999999999999,
+    #          :HEAP_USE_SIZE=>289640,
+    #          :HEAP_TOTAL_SIZE=>588960,
+    #          :HEAP_TOTAL_OBJECTS=>14724,
+    #          :GC_IS_MARKED=>false
+    #       },
+    #       # ...
+    #     ]
+    #
+    # The keys mean:
+    #
+    # `:GC_TIME`
+    # :   Time elapsed in seconds for this GC run
+    # `:GC_INVOKE_TIME`
+    # :   Time elapsed in seconds from startup to when the GC was invoked
+    # `:HEAP_USE_SIZE`
+    # :   Total bytes of heap used
+    # `:HEAP_TOTAL_SIZE`
+    # :   Total size of heap in bytes
+    # `:HEAP_TOTAL_OBJECTS`
+    # :   Total number of objects
+    # `:GC_IS_MARKED`
+    # :   Returns `true` if the GC is in mark phase
+    #
+    #
+    # If ruby was built with `GC_PROFILE_MORE_DETAIL`, you will also have access to
+    # the following hash keys:
+    #
+    # `:GC_MARK_TIME`
+    # `:GC_SWEEP_TIME`
+    # `:ALLOCATE_INCREASE`
+    # `:ALLOCATE_LIMIT`
+    # `:HEAP_USE_PAGES`
+    # `:HEAP_LIVE_OBJECTS`
+    # `:HEAP_FREE_OBJECTS`
+    # `:HAVE_FINALIZE`
+    # :
+    #
+    def self.raw_data: () -> Array[Hash[Symbol, untyped]]
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.report
+    #   - GC::Profiler.report(io)
+    # -->
+    # Writes the GC::Profiler.result to `$stdout` or the given IO object.
+    #
+    def self.report: (?_Reporter io) -> nil
+
+    interface _Reporter
+      def write: (String msg) -> void
+    end
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.result  -> String
+    # -->
+    # Returns a profile data report such as:
+    #
+    #     GC 1 invokes.
+    #     Index    Invoke Time(sec)       Use Size(byte)     Total Size(byte)         Total Object                    GC time(ms)
+    #         1               0.012               159240               212940                10647         0.00000000000001530000
+    #
+    def self.result: () -> String
+
+    # <!--
+    #   rdoc-file=gc.c
+    #   - GC::Profiler.total_time  -> float
+    # -->
+    # The total time used for garbage collection in seconds
+    #
+    def self.total_time: () -> Float
+  end
+
+  # <!-- rdoc-file=gc.c -->
+  # Internal constants in the garbage collector.
+  #
+  INTERNAL_CONSTANTS: Hash[Symbol, untyped]
+
+  # <!-- rdoc-file=gc.c -->
+  # GC build options
+  #
+  OPTS: Array[String]
+
   # <!--
   #   rdoc-file=gc.rb
   #   - GC.count -> Integer
@@ -70,7 +215,7 @@ module GC
   # are not guaranteed to be future-compatible, and may be ignored if the
   # underlying implementation does not support them.
   #
-  def self.start: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
+  def self.start: (?immediate_sweep: boolish, ?immediate_mark: boolish, ?full_mark: boolish) -> nil
 
   # <!--
   #   rdoc-file=gc.rb
@@ -156,8 +301,122 @@ module GC
   #
   # This method is only expected to work on CRuby.
   #
-  def self.stat: (?::Hash[Symbol, Integer] arg0) -> ::Hash[Symbol, Integer]
-               | (?Symbol arg0) -> Integer
+  def self.stat: (?Hash[Symbol, untyped]? hash) -> Hash[Symbol, untyped]
+               | (Symbol key) -> Integer
+
+  # <!--
+  #   rdoc-file=gc.rb
+  #   - GC.measure_total_time = true/false
+  # -->
+  # Enable to measure GC time. You can get the result with `GC.stat(:time)`. Note
+  # that GC time measurement can cause some performance overhead.
+  #
+  def self.measure_total_time=: [T] (T enable) -> T
+
+  # <!--
+  #   rdoc-file=gc.rb
+  #   - GC.measure_total_time -> true/false
+  # -->
+  # Return measure_total_time flag (default: `true`). Note that measurement can
+  # affect the application performance.
+  #
+  def self.measure_total_time: () -> bool
+
+  # <!--
+  #   rdoc-file=gc.c
+  #   - GC.auto_compact = flag
+  # -->
+  # Updates automatic compaction mode.
+  #
+  # When enabled, the compactor will execute on every major collection.
+  #
+  # Enabling compaction will degrade performance on major collections.
+  #
+  def self.auto_compact=: [T] (T enable) -> T
+
+  # <!--
+  #   rdoc-file=gc.c
+  #   - GC.auto_compact    -> true or false
+  # -->
+  # Returns whether or not automatic compaction has been enabled.
+  #
+  def self.auto_compact: () -> bool
+
+  # <!--
+  #   rdoc-file=gc.rb
+  #   - GC.stat_heap -> Hash
+  #   - GC.stat_heap(nil, hash) -> Hash
+  #   - GC.stat_heap(heap_name) -> Hash
+  #   - GC.stat_heap(heap_name, hash) -> Hash
+  #   - GC.stat_heap(heap_name, :key) -> Numeric
+  # -->
+  # Returns information for heaps in the GC.
+  #
+  # If the first optional argument, `heap_name`, is passed in and not `nil`, it
+  # returns a `Hash` containing information about the particular heap. Otherwise,
+  # it will return a `Hash` with heap names as keys and a `Hash` containing
+  # information about the heap as values.
+  #
+  # If the second optional argument, `hash_or_key`, is given as `Hash`, it will be
+  # overwritten and returned. This is intended to avoid the probe effect.
+  #
+  # If both optional arguments are passed in and the second optional argument is a
+  # symbol, it will return a `Numeric` of the value for the particular heap.
+  #
+  # On CRuby, `heap_name` is of the type `Integer` but may be of type `String` on
+  # other implementations.
+  #
+  # The contents of the hash are implementation specific and may change in the
+  # future without notice.
+  #
+  # If the optional argument, hash, is given, it is overwritten and returned.
+  #
+  # This method is only expected to work on CRuby.
+  #
+  # The hash includes the following keys about the internal information in the GC:
+  #
+  # slot_size
+  # :   The slot size of the heap in bytes.
+  # heap_allocatable_pages
+  # :   The number of pages that can be allocated without triggering a new garbage
+  #     collection cycle.
+  # heap_eden_pages
+  # :   The number of pages in the eden heap.
+  # heap_eden_slots
+  # :   The total number of slots in all of the pages in the eden heap.
+  # heap_tomb_pages
+  # :   The number of pages in the tomb heap. The tomb heap only contains pages
+  #     that do not have any live objects.
+  # heap_tomb_slots
+  # :   The total number of slots in all of the pages in the tomb heap.
+  # total_allocated_pages
+  # :   The total number of pages that have been allocated in the heap.
+  # total_freed_pages
+  # :   The total number of pages that have been freed and released back to the
+  #     system in the heap.
+  # force_major_gc_count
+  # :   The number of times major garbage collection cycles this heap has forced
+  #     to start due to running out of free slots.
+  # force_incremental_marking_finish_count
+  # :   The number of times this heap has forced incremental marking to complete
+  #     due to running out of pooled slots.
+  #
+  def self.stat_heap: (?Integer? heap_name, ?Hash[Symbol, untyped]? hash) -> Hash[Symbol, untyped]
+                    | (Integer heap_name, Symbol key) -> Integer
+
+  # <!--
+  #   rdoc-file=gc.c
+  #   - GC.latest_compact_info -> hash
+  # -->
+  # Returns information about object moved in the most recent GC compaction.
+  #
+  # The returned hash has two keys :considered and :moved.  The hash for
+  # :considered lists the number of objects that were considered for movement by
+  # the compactor, and the :moved hash lists the number of objects that were
+  # actually moved.  Some objects can't be moved (maybe they were pinned) so these
+  # numbers can be used to calculate compaction efficiency.
+  #
+  def self.latest_compact_info: () -> compact_info
 
   # <!--
   #   rdoc-file=gc.rb
@@ -165,7 +424,7 @@ module GC
   # -->
   # Returns current status of GC stress mode.
   #
-  def self.stress: () -> (Integer | TrueClass | FalseClass)
+  def self.stress: () -> (Integer | bool)
 
   # <!--
   #   rdoc-file=gc.rb
@@ -183,7 +442,8 @@ module GC
   #     0x02:: no immediate sweep
   #     0x04:: full mark after malloc/calloc/realloc
   #
-  def self.stress=: (Integer | TrueClass | FalseClass flag) -> (Integer | TrueClass | FalseClass)
+  def self.stress=: (Integer flag) -> Integer
+                  | (bool flag) -> bool
 
   # <!--
   #   rdoc-file=gc.rb
@@ -210,7 +470,11 @@ module GC
   #
   #     GC.respond_to?(:compact)
   #
-  def self.compact: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
+  def self.compact: () -> compact_info
+
+  # The type that `GC.compact` and related functions can return.
+  #
+  type compact_info = Hash[:considered | :moved |:moved_up | :moved_down, Hash[Symbol, Integer]]
 
   # <!--
   #   rdoc-file=gc.rb
@@ -227,7 +491,7 @@ module GC
   # a full GC.  If any object contains a reference to a T_MOVED object, that
   # object should be pushed on the mark stack, and will make a SEGV.
   #
-  def self.verify_compaction_references: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
+  def self.verify_compaction_references: (?toward: :empty | untyped, ?double_heap: boolish, ?expand_heap: boolish) -> compact_info
 
   # <!--
   #   rdoc-file=gc.c
@@ -251,8 +515,7 @@ module GC
   # If the optional argument, hash, is given, it is overwritten and returned. This
   # is intended to avoid probe effect.
   #
-  def self.latest_gc_info: () -> ::Hash[::Symbol, untyped]
-                         | [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
+  def self.latest_gc_info: (?Hash[Symbol, untyped]? hash) -> Hash[Symbol, untyped]
                          | (Symbol key) -> untyped
 
   # <!--
@@ -263,144 +526,3 @@ module GC
   #
   def garbage_collect: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
 end
-
-# <!-- rdoc-file=gc.c -->
-# Internal constants in the garbage collector.
-#
-GC::INTERNAL_CONSTANTS: Hash[Symbol, Integer]
-
-# <!-- rdoc-file=gc.c -->
-# GC build options
-#
-GC::OPTS: Array[String]
-
-# <!-- rdoc-file=gc.c -->
-# The GC profiler provides access to information on GC runs including time,
-# length and object space size.
-#
-# Example:
-#
-#     GC::Profiler.enable
-#
-#     require 'rdoc/rdoc'
-#
-#     GC::Profiler.report
-#
-#     GC::Profiler.disable
-#
-# See also GC.count, GC.malloc_allocated_size and GC.malloc_allocations
-#
-module GC::Profiler
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.clear          -> nil
-  # -->
-  # Clears the GC profiler data.
-  #
-  def self.clear: () -> void
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.disable      -> nil
-  # -->
-  # Stops the GC profiler.
-  #
-  def self.disable: () -> void
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.enable       -> nil
-  # -->
-  # Starts the GC profiler.
-  #
-  def self.enable: () -> void
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.enabled?     -> true or false
-  # -->
-  # The current status of GC profile mode.
-  #
-  def self.enabled?: () -> bool
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.raw_data    -> [Hash, ...]
-  # -->
-  # Returns an Array of individual raw profile data Hashes ordered from earliest
-  # to latest by `:GC_INVOKE_TIME`.
-  #
-  # For example:
-  #
-  #     [
-  #       {
-  #          :GC_TIME=>1.3000000000000858e-05,
-  #          :GC_INVOKE_TIME=>0.010634999999999999,
-  #          :HEAP_USE_SIZE=>289640,
-  #          :HEAP_TOTAL_SIZE=>588960,
-  #          :HEAP_TOTAL_OBJECTS=>14724,
-  #          :GC_IS_MARKED=>false
-  #       },
-  #       # ...
-  #     ]
-  #
-  # The keys mean:
-  #
-  # `:GC_TIME`
-  # :   Time elapsed in seconds for this GC run
-  # `:GC_INVOKE_TIME`
-  # :   Time elapsed in seconds from startup to when the GC was invoked
-  # `:HEAP_USE_SIZE`
-  # :   Total bytes of heap used
-  # `:HEAP_TOTAL_SIZE`
-  # :   Total size of heap in bytes
-  # `:HEAP_TOTAL_OBJECTS`
-  # :   Total number of objects
-  # `:GC_IS_MARKED`
-  # :   Returns `true` if the GC is in mark phase
-  #
-  #
-  # If ruby was built with `GC_PROFILE_MORE_DETAIL`, you will also have access to
-  # the following hash keys:
-  #
-  # `:GC_MARK_TIME`
-  # `:GC_SWEEP_TIME`
-  # `:ALLOCATE_INCREASE`
-  # `:ALLOCATE_LIMIT`
-  # `:HEAP_USE_PAGES`
-  # `:HEAP_LIVE_OBJECTS`
-  # `:HEAP_FREE_OBJECTS`
-  # `:HAVE_FINALIZE`
-  # :
-  #
-  def self.raw_data: () -> ::Array[::Hash[Symbol, untyped]]
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.report
-  #   - GC::Profiler.report(io)
-  # -->
-  # Writes the GC::Profiler.result to `$stdout` or the given IO object.
-  #
-  def self.report: (?IO io) -> void
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.result  -> String
-  # -->
-  # Returns a profile data report such as:
-  #
-  #     GC 1 invokes.
-  #     Index    Invoke Time(sec)       Use Size(byte)     Total Size(byte)         Total Object                    GC time(ms)
-  #         1               0.012               159240               212940                10647         0.00000000000001530000
-  #
-  def self.result: () -> String
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - GC::Profiler.total_time  -> float
-  # -->
-  # The total time used for garbage collection in seconds
-  #
-  def self.total_time: () -> Float
-end

data/core/integer.rbs

@@ -766,7 +766,8 @@ class Integer < Numeric
   #     13.divmod(Rational(4, 1)) # => [3, (1/1)]
   #
   def divmod: (Integer) -> [ Integer, Integer ]
-            | (Float) -> [ Float, Float ]
+            | (Float) -> [ Integer, Float ]
+            | (Rational) -> [ Integer, Rational ]
             | (Numeric) -> [ Numeric, Numeric ]
 
   # <!--
@@ -1028,9 +1029,10 @@ class Integer < Numeric
   #     a.pow(b)     #=> same as a**b
   #     a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values
   #
-  def pow: (Integer other, ?Integer modulo) -> Integer
-         | (Float) -> Float
-         | (Rational) -> Rational
+  def pow: (Integer other) -> (Integer | Rational)
+         | (Integer other, Integer modulo) -> Integer
+         | (Float) -> (Float | Complex)
+         | (Rational) -> (Float | Rational | Complex)
          | (Complex) -> Complex
 
   # <!--

data/core/io/wait.rbs

@@ -38,8 +38,8 @@ class IO
   #
   # You must require 'io/wait' to use this method.
   #
-  def wait: (Integer events, ?Numeric timeout) -> (Integer | false | nil)
-          | (?Numeric? timeout, *wait_mode mode) -> (self | true | false)
+  def wait: (Integer events, ?Time::_Timeout timeout) -> (Integer | false | nil)
+          | (?Time::_Timeout? timeout, *wait_mode mode) -> (self | true | false)
 
   type wait_mode = :read | :r | :readable | :write | :w | :writable | :read_write | :rw | :readable_writable
 
@@ -54,7 +54,7 @@ class IO
   #
   # You must require 'io/wait' to use this method.
   #
-  def wait_readable: (?Numeric? timeout) -> boolish
+  def wait_readable: (?Time::_Timeout? timeout) -> boolish
 
   # <!--
   #   rdoc-file=ext/io/wait/wait.c
@@ -66,5 +66,5 @@ class IO
   #
   # You must require 'io/wait' to use this method.
   #
-  def wait_writable: (?Numeric? timeout) -> boolish
+  def wait_writable: (?Time::_Timeout? timeout) -> boolish
 end

data/core/io.rbs

@@ -2087,7 +2087,14 @@ class IO < Object
   # -->
   # Get the internal timeout duration or nil if it was not set.
   #
-  def timeout: () -> Numeric?
+  def timeout: () -> io_timeout
+
+  # The type used for timeouts in `IO`.
+  #
+  # Technically, this type should be `Time::_Timeout?`. However, in the vast majority of use-cases,
+  # people aren't going to pass their own `_Timeout` in, so `Numeric` is returned for ergonomics
+  # (eg `io.timeout += 10`).
+  type io_timeout = Numeric?
 
   # <!--
   #   rdoc-file=io.c
@@ -2110,7 +2117,7 @@ class IO < Object
   # effort to prevent an application from hanging on slow I/O operations, such as
   # those that occur during a slowloris attack.
   #
-  def timeout=: (Numeric? duration) -> void
+  def timeout=: (io_timeout duration) -> void
 
   # <!--
   #   rdoc-file=io.c
@@ -2945,7 +2952,7 @@ class IO < Object
   #     ping
   #
   def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
-                 | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Numeric? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
+                 | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
 
   # <!--
   #   rdoc-file=io.c

data/core/kernel.rbs

@@ -1318,10 +1318,10 @@ 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 | Float)
+                | (::Range[Integer] arg0) -> Integer?
+                | (::Range[Float] arg0) -> Float?
 
   # <!--
   #   rdoc-file=io.c
@@ -1564,7 +1564,7 @@ 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
@@ -1581,8 +1581,9 @@ module Kernel : BasicObject
   #     Time.new  # => 2008-03-08 19:56:22 +0900
   #
   def self?.sleep: (?nil) -> bot
-                 | (Integer | Float | _Divmod duration) -> Integer
+                 | (Time::_Timeout duration) -> Integer
 
+  %a{steep:deprecated}
   interface _Divmod
     def divmod: (Numeric) -> [ Numeric, Numeric ]
   end
@@ -2332,7 +2333,7 @@ module Kernel : BasicObject
   #     k.extend(Mod)   #=> #<Klass:0x401b3bc8>
   #     k.hello         #=> "Hello from Mod.\n"
   #
-  def extend: (*Module) -> self
+  def extend: (Module, *Module) -> self
 
   # <!--
   #   rdoc-file=object.c

data/core/module.rbs

@@ -814,7 +814,7 @@ class Module < Object
   # -->
   # Invokes Module.append_features on each parameter in reverse order.
   #
-  def include: (*Module arg0) -> self
+  def include: (Module, *Module arg0) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1147,7 +1147,11 @@ class Module < Object
   #     Mod.one     #=> "This is one"
   #     c.call_one  #=> "This is the new one"
   #
-  def module_function: (*interned arg0) -> self
+  def module_function: () -> nil
+                     | (Symbol method_name) -> Symbol
+                     | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
+                     | (string method_name) -> string
+                     | (interned, interned, *interned method_name) -> Array[interned]
 
   # <!--
   #   rdoc-file=object.c
@@ -1163,7 +1167,7 @@ class Module < Object
   # -->
   # Invokes Module.prepend_features on each parameter in reverse order.
   #
-  def prepend: (*Module arg0) -> self
+  def prepend: (Module, *Module arg0) -> self
 
   # <!--
   #   rdoc-file=eval.c
@@ -1225,6 +1229,7 @@ class Module < Object
              | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
              | (string method_name) -> string
              | (interned, interned, *interned method_name) -> Array[interned]
+             | (Array[interned]) -> Array[interned]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1247,6 +1252,7 @@ class Module < Object
   #     end
   #
   def private_class_method: (*interned arg0) -> self
+                          | (Array[interned] arg0) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1326,7 +1332,12 @@ class Module < Object
   #
   # To show a private method on RDoc, use `:doc:` instead of this.
   #
-  def protected: (*interned arg0) -> self
+  def protected: () -> nil
+               | (Symbol method_name) -> Symbol
+               | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
+               | (string method_name) -> string
+               | (interned, interned, *interned method_name) -> Array[interned]
+               | (Array[interned]) -> Array[interned]
 
   # <!--
   #   rdoc-file=object.c
@@ -1386,6 +1397,7 @@ class Module < Object
             | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
             | (string method_name) -> string
             | (interned, interned, *interned method_name) -> Array[interned]
+            | (Array[interned]) -> Array[interned]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1399,6 +1411,7 @@ class Module < Object
   # is also accepted.
   #
   def public_class_method: (*interned arg0) -> self
+                         | (Array[interned] arg0) -> self
 
   # <!--
   #   rdoc-file=object.c

data/core/proc.rbs

@@ -602,7 +602,7 @@ class Proc < Object
   #     prc = lambda{|x, y=42, *other|}
   #     prc.parameters(lambda: false) #=> [[:opt, :x], [:opt, :y], [:rest, :other]]
   #
-  def parameters: (lambda: boolish) -> ::Array[[ Symbol, Symbol ]]
+  def parameters: (?lambda: boolish) -> ::Array[[ Symbol, Symbol ]]
 
   # <!--
   #   rdoc-file=proc.c

data/core/range.rbs

@@ -961,8 +961,8 @@ class Range[out Elem] < Object
   #
   # Related: Range#%.
   #
-  def step: (?Integer n) { (Elem arg0) -> untyped } -> self
-          | (?Integer n) -> ::Enumerator[Elem, void]
+  def step: (?Numeric | int n) -> Enumerator[Elem, self]
+          | (?Numeric | int n) { (Elem element) -> void } -> self
 
   # <!--
   #   rdoc-file=range.c