rbs 3.10.2 → 4.0.0.dev.1

data/core/nil_class.rbs

@@ -112,7 +112,7 @@ class NilClass
   def nil?: () -> true
 
   # <!--
-  #   rdoc-file=nilclass.rb
+  #   rdoc-file=rational.c
   #   - rationalize(eps = nil)  ->  (0/1)
   # -->
   # Returns zero as a Rational:
@@ -134,7 +134,7 @@ class NilClass
   def to_a: () -> []
 
   # <!--
-  #   rdoc-file=nilclass.rb
+  #   rdoc-file=complex.c
   #   - to_c -> (0+0i)
   # -->
   # Returns zero as a Complex:
@@ -174,7 +174,7 @@ class NilClass
   def to_i: () -> 0
 
   # <!--
-  #   rdoc-file=nilclass.rb
+  #   rdoc-file=rational.c
   #   - to_r  ->  (0/1)
   # -->
   # Returns zero as a Rational:

data/core/numeric.rbs

@@ -160,7 +160,7 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - self % other -> real_numeric
   # -->
-  # Returns `self` modulo `other` as a real numeric (Integer, Float, or Rational).
+  # Returns `self` modulo `other` as a real number.
   #
   # Of the Core and Standard Library classes, only Rational uses this
   # implementation.
@@ -212,7 +212,7 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - -self -> numeric
   # -->
-  # Returns `self`, negated.
+  # Unary Minus---Returns the receiver, negated.
   #
   def -@: () -> Numeric
 
@@ -220,15 +220,7 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - self <=> other -> zero or nil
   # -->
-  # Compares `self` and `other`.
-  #
-  # Returns:
-  #
-  # *   Zero, if `self` is the same as `other`.
-  # *   `nil`, otherwise.
-  #
-  # Class Numeric includes module Comparable, each of whose methods uses
-  # Numeric#<=> for comparison.
+  # Returns zero if `self` is the same as `other`, `nil` otherwise.
   #
   # No subclass in the Ruby Core or Standard Library uses this implementation.
   #
@@ -344,7 +336,7 @@ class Numeric
   #   - div(other) -> integer
   # -->
   # Returns the quotient `self/other` as an integer (via `floor`), using method
-  # `/` as defined in the subclass of Numeric. (Numeric itself does not define
+  # `/` in the derived class of `self`. (Numeric itself does not define method
   # `/`.)
   #
   # Of the Core and Standard Library classes, Only Float and Rational use this
@@ -406,8 +398,8 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - fdiv(other) -> float
   # -->
-  # Returns the quotient `self/other` as a float, using method `/` as defined in
-  # the subclass of Numeric. (Numeric itself does not define `/`.)
+  # Returns the quotient `self/other` as a float, using method `/` in the derived
+  # class of `self`. (Numeric itself does not define method `/`.)
   #
   # Of the Core and Standard Library classes, only BigDecimal uses this
   # implementation.
@@ -496,7 +488,7 @@ class Numeric
   alias magnitude abs
 
   # <!-- rdoc-file=numeric.c -->
-  # Returns `self` modulo `other` as a real numeric (Integer, Float, or Rational).
+  # Returns `self` modulo `other` as a real number.
   #
   # Of the Core and Standard Library classes, only Rational uses this
   # implementation.
@@ -538,17 +530,17 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - nonzero?  ->  self or nil
   # -->
-  # Returns `self` if `self` is not a zero value, `nil` otherwise; uses method
-  # `zero?` for the evaluation.
+  # Returns +self+ if +self+ is not a zero value, +nil+ otherwise;
+  #     uses method <tt>zero?</tt> for the evaluation.
   #
-  # The returned `self` allows the method to be chained:
+  #     The returned +self+ allows the method to be chained:
   #
-  #     a = %w[z Bb bB bb BB a aA Aa AA A]
-  #     a.sort {|a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
-  #     # => ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]
+  #       a = %w[z Bb bB bb BB a aA Aa AA A]
+  #       a.sort {|a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
+  #       # => ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]
   #
-  # Of the Core and Standard Library classes, Integer, Float, Rational, and
-  # Complex use this implementation.
+  #     Of the Core and Standard Library classes,
+  #     Integer, Float, Rational, and Complex use this implementation.
   #
   # Related: #zero?
   #
@@ -773,8 +765,8 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - to_int -> integer
   # -->
-  # Returns `self` as an integer; converts using method `to_i` in the subclass of
-  # Numeric. (Numeric itself does not define `to_i`.)
+  # Returns `self` as an integer; converts using method `to_i` in the derived
+  # class.
   #
   # Of the Core and Standard Library classes, only Rational and Complex use this
   # implementation.

data/core/object.rbs

@@ -40,7 +40,7 @@
 # *   #instance_of?: Returns whether `self` is an instance of the given class.
 # *   #instance_variable_defined?: Returns whether the given instance variable
 #     is defined in `self`.
-# *   #method: Returns the `Method` object for the given method in `self`.
+# *   #method: Returns the Method object for the given method in `self`.
 # *   #methods: Returns an array of symbol names of public and protected methods
 #     in `self`.
 # *   #nil?: Returns `false`. (Only `nil` responds `true` to method `nil?`.)
@@ -50,13 +50,13 @@
 #     methods in `self`.
 # *   #protected_methods: Returns an array of the symbol names of the protected
 #     methods in `self`.
-# *   #public_method: Returns the `Method` object for the given public method in
+# *   #public_method: Returns the Method object for the given public method in
 #     `self`.
 # *   #public_methods: Returns an array of the symbol names of the public
 #     methods in `self`.
 # *   #respond_to?: Returns whether `self` responds to the given method.
 # *   #singleton_class: Returns the singleton class of `self`.
-# *   #singleton_method: Returns the `Method` object for the given singleton
+# *   #singleton_method: Returns the Method object for the given singleton
 #     method in `self`.
 # *   #singleton_methods: Returns an array of the symbol names of the singleton
 #     methods in `self`.

data/core/object_space.rbs

@@ -29,7 +29,6 @@ module ObjectSpace
   #   - _id2ref(p1)
   # -->
   #
-  %a{deprecated}
   def self._id2ref: (Integer id) -> untyped
 
   # <!--
@@ -137,33 +136,28 @@ module ObjectSpace
   # Calls the block once for each living, nonimmediate object in this Ruby
   # process. If *module* is specified, calls the block for only those classes or
   # modules that match (or are a subclass of) *module*. Returns the number of
-  # objects found. Immediate objects (such as `Fixnum`s, static `Symbol`s `true`,
-  # `false` and `nil`) are never returned.
+  # objects found. Immediate objects (`Fixnum`s, `Symbol`s `true`, `false`, and
+  # `nil`) are never returned. In the example below, #each_object returns both the
+  # numbers we defined and several constants defined in the Math module.
   #
   # If no block is given, an enumerator is returned instead.
   #
-  #     Job = Class.new
-  #     jobs = [Job.new, Job.new]
-  #     count = ObjectSpace.each_object(Job) {|x| p x }
+  #     a = 102.7
+  #     b = 95       # Won't be returned
+  #     c = 12345678987654321
+  #     count = ObjectSpace.each_object(Numeric) {|x| p x }
   #     puts "Total count: #{count}"
   #
   # *produces:*
   #
-  #     #<Job:0x000000011d6cbbf0>
-  #     #<Job:0x000000011d6cbc68>
-  #      Total count: 2
-  #
-  # Due to a current Ractor implementation issue, this method does not yield
-  # Ractor-unshareable objects when the process is in multi-Ractor mode.
-  # Multi-ractor mode is enabled when `Ractor.new` has been called for the first
-  # time. See https://bugs.ruby-lang.org/issues/19387 for more information.
-  #
-  #     a = 12345678987654321 # shareable
-  #     b = [].freeze # shareable
-  #     c = {} # not shareable
-  #     ObjectSpace.each_object {|x| x } # yields a, b, and c
-  #     Ractor.new {} # enter multi-Ractor mode
-  #     ObjectSpace.each_object {|x| x } # does not yield c
+  #     12345678987654321
+  #     102.7
+  #     2.71828182845905
+  #     3.14159265358979
+  #     2.22044604925031e-16
+  #     1.7976931348623157e+308
+  #     2.2250738585072e-308
+  #     Total count: 7
   #
   def self.each_object: (?Module `module`) -> Enumerator[untyped, Integer]
                       | (?Module `module`) { (untyped obj) -> void } -> Integer

data/core/proc.rbs

@@ -201,8 +201,8 @@
 #     ["Bob", "Jane"].map(&hi)    #=> ["Hi, Bob!", "Hi, Jane!"]
 #     ["Bob", "Jane"].map(&hey)   #=> ["Hey, Bob!", "Hey, Jane!"]
 #
-# Of the Ruby core classes, this method is implemented by `Symbol`, `Method`,
-# and `Hash`.
+# Of the Ruby core classes, this method is implemented by Symbol, Method, and
+# Hash.
 #
 #     :to_s.to_proc.call(1)           #=> "1"
 #     [1, 2].map(&:to_s)              #=> ["1", "2"]
@@ -285,7 +285,7 @@
 #     [1, 2, 3].each { |x| p it }
 #     # syntax error found (SyntaxError)
 #     # [1, 2, 3].each { |x| p it }
-#     #                        ^~ 'it' is not allowed when an ordinary parameter is defined
+#     #                        ^~ `it` is not allowed when an ordinary parameter is defined
 #
 # But if a local name (variable or method) is available, it would be used:
 #
@@ -302,7 +302,7 @@
 #
 #     p = proc { it**2 }
 #     l = lambda { it**2 }
-#     p.parameters     # => [[:opt]]
+#     p.parameters     # => [[:opt, nil]]
 #     p.arity          # => 1
 #     l.parameters     # => [[:req]]
 #     l.arity          # => 1
@@ -332,7 +332,7 @@
 # Numbered parameters can't be mixed with `it` either:
 #
 #     [10, 20, 30].map { _1 + it }
-#     # SyntaxError: 'it' is not allowed when a numbered parameter is already used
+#     # SyntaxError: `it` is not allowed when a numbered parameter is already used
 #
 # To avoid conflicts, naming local variables or method arguments `_1`, `_2` and
 # so on, causes an error.
@@ -380,9 +380,9 @@ class Proc
   def dup: () -> self
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the arguments using
-  # something close to method calling semantics. Returns the value of the last
-  # expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the values in *params*
+  # using something close to method calling semantics. Returns the value of the
+  # last expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -409,9 +409,9 @@ class Proc
   alias === call
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the arguments using
-  # something close to method calling semantics. Returns the value of the last
-  # expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the values in *params*
+  # using something close to method calling semantics. Returns the value of the
+  # last expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -592,13 +592,14 @@ class Proc
 
   # <!--
   #   rdoc-file=proc.c
-  #   - call(...) -> obj
-  #   - self[...] -> obj
-  #   - yield(...) -> obj
+  #   - prc.call(params,...)   -> obj
+  #   - prc[params,...]        -> obj
+  #   - prc.(params,...)       -> obj
+  #   - prc.yield(params,...)  -> obj
   # -->
-  # Invokes the block, setting the block's parameters to the arguments using
-  # something close to method calling semantics. Returns the value of the last
-  # expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the values in *params*
+  # using something close to method calling semantics. Returns the value of the
+  # last expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -625,9 +626,9 @@ class Proc
   def call: (?) -> untyped
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the arguments using
-  # something close to method calling semantics. Returns the value of the last
-  # expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the values in *params*
+  # using something close to method calling semantics. Returns the value of the
+  # last expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -834,17 +835,10 @@ class Proc
 
   # <!--
   #   rdoc-file=proc.c
-  #   - prc.source_location  -> [String, Integer, Integer, Integer, Integer]
+  #   - prc.source_location  -> [String, Integer]
   # -->
-  # Returns the location where the Proc was defined. The returned Array contains:
-  #     (1) the Ruby source filename
-  #     (2) the line number where the definition starts
-  #     (3) the column number where the definition starts
-  #     (4) the line number where the definition ends
-  #     (5) the column number where the definitions ends
-  #
-  # This method will return `nil` if the Proc was not defined in Ruby (i.e.
-  # native).
+  # Returns the Ruby source filename and line number containing this proc or `nil`
+  # if this proc was not defined in Ruby (i.e. native).
   #
   def source_location: () -> [String, Integer]?
 

data/core/process.rbs

@@ -590,7 +590,7 @@ module Process
   # *   `:microsecond`: Number of microseconds as an integer.
   # *   `:millisecond`: Number of milliseconds as an integer.
   # *   `:nanosecond`: Number of nanoseconds as an integer.
-  # *   `:second`: Number of seconds as an integer.
+  # *   `::second`: Number of seconds as an integer.
   #
   # Examples:
   #
@@ -2023,7 +2023,7 @@ end
 # <!-- rdoc-file=process.c -->
 # The Process::Sys module contains UID and GID functions which provide direct
 # bindings to the system calls of the same names instead of the more-portable
-# versions of the same functionality found in the `Process`, Process::UID, and
+# versions of the same functionality found in the Process, Process::UID, and
 # Process::GID modules.
 #
 module Process::Sys