steep 0.14.0 → 0.15.0

data/vendor/ruby-signature/stdlib/builtin/gc.rbs

@@ -1,121 +1,243 @@
-# The [GC](GC) module provides an interface to Ruby’s
-# mark and sweep garbage collection mechanism.
-# 
-# Some of the underlying methods are also available via the
-# [ObjectSpace](https://ruby-doc.org/core-2.6.3/ObjectSpace.html) module.
-# 
-# You may obtain information about the operation of the
-# [GC](GC) through
-# [GC::Profiler](https://ruby-doc.org/core-2.6.3/GC/Profiler.html).
+# The GC module provides an interface to Ruby's mark and sweep garbage
+# collection mechanism.
+#
+# Some of the underlying methods are also available via the ObjectSpace module.
+#
+# You may obtain information about the operation of the GC through GC::Profiler.
+#
 module GC
-  # The number of times [GC](GC.downloaded.ruby_doc) occurred.
-  # 
-  # It returns the number of times [GC](GC.downloaded.ruby_doc) occurred
-  # since the process started.
+  # The number of times GC occurred.
+  #
+  # It returns the number of times GC occurred since the process started.
+  #
   def self.count: () -> Integer
 
   # Disables garbage collection, returning `true` if garbage collection was
   # already disabled.
-  # 
-  # ```ruby
-  # GC.disable   #=> false
-  # GC.disable   #=> true
-  # ```
+  #
+  #     GC.disable   #=> false
+  #     GC.disable   #=> true
+  #
   def self.disable: () -> bool
 
   # Enables garbage collection, returning `true` if garbage collection was
   # previously disabled.
-  # 
-  # ```ruby
-  # GC.disable   #=> false
-  # GC.enable    #=> true
-  # GC.enable    #=> false
-  # ```
+  #
+  #     GC.disable   #=> false
+  #     GC.enable    #=> true
+  #     GC.enable    #=> false
+  #
   def self.enable: () -> bool
 
-  def self.start: (?full_mark: bool full_mark, ?immediate_mark: bool immediate_mark, ?immediate_sweep: bool immediate_sweep) -> nil
-
-  # Returns a [Hash](https://ruby-doc.org/core-2.6.3/Hash.html) containing
-  # information about the [GC](GC.downloaded.ruby_doc).
-  # 
-  # The hash includes information about internal statistics about
-  # [GC](GC.downloaded.ruby_doc) such as:
-  # 
-  # ```ruby
-  # {
-  #     :count=>0,
-  #     :heap_allocated_pages=>24,
-  #     :heap_sorted_length=>24,
-  #     :heap_allocatable_pages=>0,
-  #     :heap_available_slots=>9783,
-  #     :heap_live_slots=>7713,
-  #     :heap_free_slots=>2070,
-  #     :heap_final_slots=>0,
-  #     :heap_marked_slots=>0,
-  #     :heap_eden_pages=>24,
-  #     :heap_tomb_pages=>0,
-  #     :total_allocated_pages=>24,
-  #     :total_freed_pages=>0,
-  #     :total_allocated_objects=>7796,
-  #     :total_freed_objects=>83,
-  #     :malloc_increase_bytes=>2389312,
-  #     :malloc_increase_bytes_limit=>16777216,
-  #     :minor_gc_count=>0,
-  #     :major_gc_count=>0,
-  #     :remembered_wb_unprotected_objects=>0,
-  #     :remembered_wb_unprotected_objects_limit=>0,
-  #     :old_objects=>0,
-  #     :old_objects_limit=>0,
-  #     :oldmalloc_increase_bytes=>2389760,
-  #     :oldmalloc_increase_bytes_limit=>16777216
-  # }
-  # ```
-  # 
-  # The contents of the hash are implementation specific and may be changed
-  # in the future.
-  # 
+  # Initiates garbage collection, even if manually disabled.
+  #
+  # This method is defined with keyword arguments that default to true:
+  #
+  #     def GC.start(full_mark: true, immediate_sweep: true); end
+  #
+  # Use full_mark: false to perform a minor GC. Use immediate_sweep: false to
+  # defer sweeping (use lazy sweep).
+  #
+  # Note: These keyword arguments are implementation and version dependent. They
+  # are not guaranteed to be future-compatible, and may be ignored if the
+  # underlying implementation does not support them.
+  #
+  def self.start: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+
+  # Returns a Hash containing information about the GC.
+  #
+  # The hash includes information about internal statistics about GC such as:
+  #
+  #     {
+  #         :count=>0,
+  #         :heap_allocated_pages=>24,
+  #         :heap_sorted_length=>24,
+  #         :heap_allocatable_pages=>0,
+  #         :heap_available_slots=>9783,
+  #         :heap_live_slots=>7713,
+  #         :heap_free_slots=>2070,
+  #         :heap_final_slots=>0,
+  #         :heap_marked_slots=>0,
+  #         :heap_eden_pages=>24,
+  #         :heap_tomb_pages=>0,
+  #         :total_allocated_pages=>24,
+  #         :total_freed_pages=>0,
+  #         :total_allocated_objects=>7796,
+  #         :total_freed_objects=>83,
+  #         :malloc_increase_bytes=>2389312,
+  #         :malloc_increase_bytes_limit=>16777216,
+  #         :minor_gc_count=>0,
+  #         :major_gc_count=>0,
+  #         :remembered_wb_unprotected_objects=>0,
+  #         :remembered_wb_unprotected_objects_limit=>0,
+  #         :old_objects=>0,
+  #         :old_objects_limit=>0,
+  #         :oldmalloc_increase_bytes=>2389760,
+  #         :oldmalloc_increase_bytes_limit=>16777216
+  #     }
+  #
+  # The contents of the hash are implementation specific and may be changed in the
+  # future.
+  #
   # This method is only expected to work on C Ruby.
+  #
   def self.stat: (?::Hash[Symbol, Integer] arg0) -> ::Hash[Symbol, Integer]
                | (?Symbol arg0) -> Integer
 
-  # Returns current status of [GC](GC.downloaded.ruby_doc) stress mode.
+  # Returns current status of GC stress mode.
+  #
   def self.stress: () -> (Integer | TrueClass | FalseClass)
 
-  def self.stress=: ((Integer | TrueClass | FalseClass) flag) -> (Integer | TrueClass | FalseClass)
+  # Updates the GC stress mode.
+  #
+  # When stress mode is enabled, the GC is invoked at every GC opportunity: all
+  # memory and object allocations.
+  #
+  # Enabling stress mode will degrade performance, it is only for debugging.
+  #
+  # flag can be true, false, or an integer bit-ORed following flags.
+  #     0x01:: no major GC
+  #     0x02:: no immediate sweep
+  #     0x04:: full mark after malloc/calloc/realloc
+  #
+  def self.stress=: (Integer | TrueClass | FalseClass flag) -> (Integer | TrueClass | FalseClass)
 
   def self.compact: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
 
+  # Verify compaction reference consistency.
+  #
+  # This method is implementation specific.  During compaction, objects that were
+  # moved are replaced with T_MOVED objects.  No object should have a reference to
+  # a T_MOVED object after compaction.
+  #
+  # This function doubles the heap to ensure room to move all objects, compacts
+  # the heap to make sure everything moves, updates all references, then performs
+  # 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]]
 
+  # Verify internal consistency.
+  #
+  # This method is implementation specific. Now this method checks generational
+  # consistency if RGenGC is supported.
+  #
   def self.verify_internal_consistency: () -> nil
 
   def self.verify_transient_heap_internal_consistency: () -> nil
 
+  # Returns information about the most recent garbage collection.
+  #
   def self.latest_gc_info: () -> ::Hash[::Symbol, untyped]
                          | [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
                          | (Symbol key) -> untyped
 
-  def garbage_collect: (?full_mark: bool full_mark, ?immediate_mark: bool immediate_mark, ?immediate_sweep: bool immediate_sweep) -> nil
+  def garbage_collect: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
 end
 
+# internal constants
+#
+#
 GC::INTERNAL_CONSTANTS: Hash[Symbol, Integer]
 
+# GC build options
+#
+#
 GC::OPTS: Array[String]
 
+# 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
+  # Clears the GC profiler data.
+  #
   def self.clear: () -> void
 
+  # Stops the GC profiler.
+  #
   def self.disable: () -> void
 
+  # Starts the GC profiler.
+  #
   def self.enable: () -> void
 
+  # The current status of GC profile mode.
+  #
   def self.enabled?: () -> bool
 
+  # 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]]
 
+  # Writes the GC::Profiler.result to `$stdout` or the given IO object.
+  #
   def self.report: (?IO io) -> void
 
+  # 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
 
+  # The total time used for garbage collection in seconds
+  #
   def self.total_time: () -> Float
 end

data/vendor/ruby-signature/stdlib/builtin/integer.rbs

@@ -45,7 +45,6 @@ class Integer < Numeric
        | (Rational) -> Rational
        | (Complex) -> Complex
        | (Integer) -> Integer
-       | (Numeric) -> Numeric
 
   # Raises `int` to the power of `numeric`, which may be negative or fractional.
   # The result may be an Integer, a Float, a Rational, or a complex number.
@@ -63,7 +62,6 @@ class Integer < Numeric
         | (Float) -> Numeric
         | (Rational) -> Numeric
         | (Complex) -> Complex
-        | (Numeric) -> Numeric
 
   # Performs addition: the class of the resulting object depends on the class of
   # `numeric`.
@@ -72,7 +70,6 @@ class Integer < Numeric
        | (Float) -> Float
        | (Rational) -> Rational
        | (Complex) -> Complex
-       | (Numeric) -> Numeric
 
   def +@: () -> Integer
 
@@ -83,7 +80,6 @@ class Integer < Numeric
        | (Float) -> Float
        | (Rational) -> Rational
        | (Complex) -> Complex
-       | (Numeric) -> Numeric
 
   # Returns `int`, negated.
   #
@@ -96,7 +92,6 @@ class Integer < Numeric
        | (Float) -> Float
        | (Rational) -> Rational
        | (Complex) -> Complex
-       | (Numeric) -> Numeric
 
   # Returns `true` if the value of `int` is less than that of `real`.
   #
@@ -475,7 +470,9 @@ class Integer < Numeric
   #     a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values
   #
   def pow: (Integer other, ?Integer modulo) -> Integer
-         | (Numeric numeric) -> Numeric
+         | (Float) -> Float
+         | (Rational) -> Rational
+         | (Complex) -> Complex
 
   # Returns the predecessor of `int`, i.e. the Integer equal to `int-1`.
   #

data/vendor/ruby-signature/stdlib/builtin/kernel.rbs

@@ -302,19 +302,19 @@ module Kernel
   # The optional second parameter sets the message associated with the
   # exception, and the third parameter is an array of callback information.
   # Exceptions are caught by the `rescue` clause of `begin...end` blocks.
-  # 
+  #
   # ```ruby
   # raise "Failed to create socket"
   # raise ArgumentError, "No parameters", caller
   # ```
-  # 
+  #
   # The `cause` of the generated exception 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.
   def fail: () -> bot
           | (String arg0) -> bot
-          | (?Exception arg0, ?String arg1, ?::Array[String] arg2) -> bot
+          | (_Exception arg0, ?untyped arg1, ?::Array[String] arg2) -> bot
   alias raise fail
 
   def format: (String format, *untyped args) -> String
@@ -384,7 +384,9 @@ module Kernel
   #     cat, 1, 2, 3, 99
   def print: (*Kernel args) -> nil
 
-  def printf: (?IO arg0, ?String arg1, *untyped arg2) -> nil
+  def printf: (IO arg0, String arg1, *untyped args) -> nil
+            | (String arg1, *untyped args) -> nil
+            | -> nil
 
   def proc: () { () -> untyped } -> Proc