rbs 3.9.5 → 3.10.0.pre.1

data/core/array.rbs

@@ -151,8 +151,8 @@
 #
 # ## Example Usage
 #
-# In addition to the methods it mixes in through the Enumerable module, the
-# `Array` class has proprietary methods for accessing, searching and otherwise
+# In addition to the methods it mixes in through the Enumerable module, class
+# Array has proprietary methods for accessing, searching and otherwise
 # manipulating arrays.
 #
 # Some of the more common ones are illustrated below.
@@ -200,9 +200,9 @@
 #
 #     arr.drop(3) #=> [4, 5, 6]
 #
-# ## Obtaining Information about an `Array`
+# ## Obtaining Information about an Array
 #
-# Arrays keep track of their own length at all times.  To query an array about
+# An array keeps track of its own length at all times.  To query an array about
 # the number of elements it contains, use #length, #count or #size.
 #
 #     browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
@@ -217,7 +217,7 @@
 #
 #     browsers.include?('Konqueror') #=> false
 #
-# ## Adding Items to Arrays
+# ## Adding Items to an Array
 #
 # Items can be added to the end of an array by using either #push or #<<
 #
@@ -238,7 +238,7 @@
 #     arr.insert(3, 'orange', 'pear', 'grapefruit')
 #     #=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]
 #
-# ## Removing Items from an `Array`
+# ## Removing Items from an Array
 #
 # The method #pop removes the last element in an array and returns it:
 #
@@ -277,12 +277,12 @@
 #     arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
 #     arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]
 #
-# ## Iterating over Arrays
+# ## Iterating over an Array
 #
-# Like all classes that include the Enumerable module, `Array` has an each
+# Like all classes that include the Enumerable module, class Array has an each
 # method, which defines what elements should be iterated over and how.  In case
-# of Array's #each, all elements in the `Array` instance are yielded to the
-# supplied block in sequence.
+# of Array#each, all elements in `self` are yielded to the supplied block in
+# sequence.
 #
 # Note that this operation leaves the array unchanged.
 #
@@ -307,7 +307,7 @@
 #     arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
 #     arr                   #=> [1, 4, 9, 16, 25]
 #
-# ## Selecting Items from an `Array`
+# ## Selecting Items from an Array
 #
 # Elements can be selected from an array according to criteria defined in a
 # block.  The selection can happen in a destructive or a non-destructive manner.
@@ -340,13 +340,13 @@
 #
 # ## What's Here
 #
-# First, what's elsewhere. Class `Array`:
+# First, what's elsewhere. Class Array:
 #
 # *   Inherits from [class Object](rdoc-ref:Object@What-27s+Here).
 # *   Includes [module Enumerable](rdoc-ref:Enumerable@What-27s+Here), which
 #     provides dozens of additional methods.
 #
-# Here, class `Array` provides methods that are useful for:
+# Here, class Array provides methods that are useful for:
 #
 # *   [Creating an Array](rdoc-ref:Array@Methods+for+Creating+an+Array)
 # *   [Querying](rdoc-ref:Array@Methods+for+Querying)
@@ -359,7 +359,7 @@
 # *   [Converting](rdoc-ref:Array@Methods+for+Converting)
 # *   [And more....](rdoc-ref:Array@Other+Methods)
 #
-# ### Methods for Creating an `Array`
+# ### Methods for Creating an Array
 #
 # *   ::[]: Returns a new array populated with given objects.
 # *   ::new: Returns a new array.
@@ -524,7 +524,7 @@
 #     return-value.
 # *   #flatten: Returns an array that is a recursive flattening of `self`.
 # *   #inspect (aliased as #to_s): Returns a new String containing the elements.
-# *   #join: Returns a newsString containing the elements joined by the field
+# *   #join: Returns a new String containing the elements joined by the field
 #     separator.
 # *   #to_a: Returns `self` or a new array containing all elements.
 # *   #to_ary: Returns `self`.
@@ -840,9 +840,8 @@ class Array[unchecked out Elem] < Object
   #
   # If `index` is out of range, returns `nil`.
   #
-  # When two Integer arguments `start` and `length` are given, returns a new
-  # `Array` of size `length` containing successive elements beginning at offset
-  # `start`:
+  # When two Integer arguments `start` and `length` are given, returns a new array
+  # of size `length` containing successive elements beginning at offset `start`:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] # => [:foo, "bar"]
@@ -856,7 +855,7 @@ class Array[unchecked out Elem] < Object
   #     a[1, 3] # => ["bar", 2]
   #     a[2, 2] # => [2]
   #
-  # If `start == self.size` and `length >= 0`, returns a new empty `Array`.
+  # If `start == self.size` and `length >= 0`, returns a new empty array.
   #
   # If `length` is negative, returns `nil`.
   #
@@ -867,7 +866,7 @@ class Array[unchecked out Elem] < Object
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
   #
-  # Special case: If `range.start == a.size`, returns a new empty `Array`.
+  # Special case: If `range.start == a.size`, returns a new empty array.
   #
   # If `range.end` is negative, calculates the end index from the end:
   #
@@ -891,7 +890,7 @@ class Array[unchecked out Elem] < Object
   #     a[4..-1] # => nil
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
-  # an `Array` of elements corresponding to the indexes produced by the sequence.
+  # an array of elements corresponding to the indexes produced by the sequence.
   #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
@@ -976,8 +975,8 @@ class Array[unchecked out Elem] < Object
   #     a # => [:foo, "bar", "two"]
   #
   # When Integer arguments `start` and `length` are given and `object` is not an
-  # `Array`, removes `length - 1` elements beginning at offset `start`, and
-  # assigns `object` at offset `start`:
+  # array, removes `length - 1` elements beginning at offset `start`, and assigns
+  # `object` at offset `start`:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] = 'foo' # => "foo"
@@ -1010,7 +1009,7 @@ class Array[unchecked out Elem] < Object
   #     a[1, 5] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
   #
-  # When Range argument `range` is given and `object` is not an `Array`, removes
+  # When Range argument `range` is given and `object` is not an array, removes
   # `length - 1` elements beginning at offset `start`, and assigns `object` at
   # offset `start`:
   #
@@ -1274,9 +1273,9 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - collect! {|element| ... } -> new_array
+  #   - collect! {|element| ... } -> self
   #   - collect! -> new_enumerator
-  #   - map! {|element| ... } -> new_array
+  #   - map! {|element| ... } -> self
   #   - map! -> new_enumerator
   # -->
   # With a block given, calls the block with each element of `self` and replaces
@@ -1564,7 +1563,7 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.dig(index, *identifiers) -> object
+  #   - dig(index, *identifiers) -> object
   # -->
   # Finds and returns the object in nested object specified by `index` and
   # `identifiers`; the nested objects may be instances of various classes. See
@@ -1693,7 +1692,7 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.empty?  -> true or false
+  #   - empty?  -> true or false
   # -->
   # Returns `true` if the count of elements in `self` is zero, `false` otherwise.
   #
@@ -1804,10 +1803,10 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - fill(object, start = nil, count = nil) -> new_array
-  #   - fill(object, range) -> new_array
-  #   - fill(start = nil, count = nil) {|element| ... } -> new_array
-  #   - fill(range) {|element| ... } -> new_array
+  #   - fill(object, start = nil, count = nil) -> self
+  #   - fill(object, range) -> self
+  #   - fill(start = nil, count = nil) {|element| ... } -> self
+  #   - fill(range) {|element| ... } -> self
   # -->
   # Replaces selected elements in `self`; may add elements to `self`; always
   # returns `self` (never a new array).
@@ -2300,7 +2299,7 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.join(separator = $,) -> new_string
+  #   - join(separator = $,) -> new_string
   # -->
   # Returns the new string formed by joining the converted elements of `self`; for
   # each element `element`:
@@ -3115,7 +3114,7 @@ class Array[unchecked out Elem] < Object
   #
   # The order of the result array is unrelated to the order of `self`.
   #
-  # Returns a new empty `Array` if `self` is empty:
+  # Returns a new empty array if `self` is empty:
   #
   #     [].sample(4) # => []
   #
@@ -3320,9 +3319,8 @@ class Array[unchecked out Elem] < Object
   #
   # If `index` is out of range, returns `nil`.
   #
-  # When two Integer arguments `start` and `length` are given, returns a new
-  # `Array` of size `length` containing successive elements beginning at offset
-  # `start`:
+  # When two Integer arguments `start` and `length` are given, returns a new array
+  # of size `length` containing successive elements beginning at offset `start`:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] # => [:foo, "bar"]
@@ -3336,7 +3334,7 @@ class Array[unchecked out Elem] < Object
   #     a[1, 3] # => ["bar", 2]
   #     a[2, 2] # => [2]
   #
-  # If `start == self.size` and `length >= 0`, returns a new empty `Array`.
+  # If `start == self.size` and `length >= 0`, returns a new empty array.
   #
   # If `length` is negative, returns `nil`.
   #
@@ -3347,7 +3345,7 @@ class Array[unchecked out Elem] < Object
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
   #
-  # Special case: If `range.start == a.size`, returns a new empty `Array`.
+  # Special case: If `range.start == a.size`, returns a new empty array.
   #
   # If `range.end` is negative, calculates the end index from the end:
   #
@@ -3371,7 +3369,7 @@ class Array[unchecked out Elem] < Object
   #     a[4..-1] # => nil
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
-  # an `Array` of elements corresponding to the indexes produced by the sequence.
+  # an array of elements corresponding to the indexes produced by the sequence.
   #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
@@ -3518,6 +3516,9 @@ class Array[unchecked out Elem] < Object
   # When the block returns zero, the order for `a` and `b` is indeterminate, and
   # may be unstable.
   #
+  # See an example in Numeric#nonzero? for the idiom to sort more complex
+  # structure.
+  #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
   def sort: () -> ::Array[Elem]
@@ -3647,7 +3648,7 @@ class Array[unchecked out Elem] < Object
   #   rdoc-file=array.c
   #   - to_a -> self or new_array
   # -->
-  # When `self` is an instance of `Array`, returns `self`.
+  # When `self` is an instance of Array, returns `self`.
   #
   # Otherwise, returns a new array containing the elements of `self`:
   #
@@ -3663,7 +3664,7 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.to_ary -> self
+  #   - to_ary -> self
   # -->
   # Returns `self`.
   #
@@ -4008,7 +4009,7 @@ class Array[unchecked out Elem] < Object
   #      [:c3, :b3, :a3]]
   #
   # For an **object** in **other_arrays** that is not actually an array, forms the
-  # the "other array" as `object.to_ary`, if defined, or as `object.each.to_a`
+  # "other array" as `object.to_ary`, if defined, or as `object.each.to_a`
   # otherwise.
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).

data/core/dir.rbs

@@ -477,8 +477,8 @@ class Dir
 
   # <!--
   #   rdoc-file=dir.rb
-  #   - Dir.glob(*patterns, flags: 0, base: nil, sort: true) -> array
-  #   - Dir.glob(*patterns, flags: 0, base: nil, sort: true) {|entry_name| ... } -> nil
+  #   - Dir.glob(patterns, flags: 0, base: nil, sort: true) -> array
+  #   - Dir.glob(patterns, flags: 0, base: nil, sort: true) {|entry_name| ... } -> nil
   # -->
   # Forms an array *entry_names* of the entry names selected by the arguments.
   #

data/core/encoding.rbs

@@ -923,8 +923,9 @@ class Encoding::Converter < Object
   #     p ec.primitive_convert(src, dst, nil, 1)             #=> :destination_buffer_full
   #     p ec.last_error      #=> nil
   #
-  def last_error: () -> Encoding::InvalidByteSequenceError?
-                | () -> Encoding::UndefinedConversionError?
+  def last_error: () -> ( Encoding::InvalidByteSequenceError
+                        | Encoding::UndefinedConversionError
+                        | nil )
 
   # <!--
   #   rdoc-file=transcode.c

data/core/enumerable.rbs

@@ -114,8 +114,8 @@
 #     by the block.
 # *   #grep: Returns elements selected by a given object or objects returned by
 #     a given block.
-# *   #grep_v: Returns elements selected by a given object or objects returned
-#     by a given block.
+# *   #grep_v: Returns elements not selected by a given object or objects
+#     returned by a given block.
 # *   #inject (aliased as #reduce): Returns the object formed by combining all
 #     elements.
 # *   #sum: Returns the sum of the elements, using method `+`.
@@ -191,6 +191,82 @@
 #     usage would not make sense, and so it is not shown.  Example: #tally would
 #     find exactly one of each Hash entry.
 #
+# ## Extended Methods
+#
+# A Enumerable class may define extended methods. This section describes the
+# standard behavior of extension methods for reference purposes.
+#
+# ### #size
+#
+# Enumerator has a #size method. It uses the size function argument passed to
+# `Enumerator.new`.
+#
+#     e = Enumerator.new(-> { 3 }) {|y| p y; y.yield :a; y.yield :b; y.yield :c; :z }
+#     p e.size #=> 3
+#     p e.next #=> :a
+#     p e.next #=> :b
+#     p e.next #=> :c
+#     begin
+#       e.next
+#     rescue StopIteration
+#       p $!.result #=> :z
+#     end
+#
+# The result of the size function should represent the number of iterations
+# (i.e., the number of times Enumerator::Yielder#yield is called). In the above
+# example, the block calls #yield three times, and the size function, +-> { 3
+# }+, returns 3 accordingly. The result of the size function can be an integer,
+# `Float::INFINITY`, or `nil`. An integer means the exact number of times #yield
+# will be called, as shown above. `Float::INFINITY` indicates an infinite number
+# of #yield calls. `nil` means the number of #yield calls is difficult or
+# impossible to determine.
+#
+# Many iteration methods return an Enumerator object with an appropriate size
+# function if no block is given.
+#
+# Examples:
+#
+#     ["a", "b", "c"].each.size #=> 3
+#     {a: "x", b: "y", c: "z"}.each.size #=> 3
+#     (0..20).to_a.permutation.size #=> 51090942171709440000
+#     loop.size #=> Float::INFINITY
+#     (1..100).drop_while.size #=> nil  # size depends on the block's behavior
+#     STDIN.each.size #=> nil # cannot be computed without consuming input
+#     File.open("/etc/resolv.conf").each.size #=> nil # cannot be computed without reading the file
+#
+# The behavior of #size for Range-based enumerators depends on the #begin
+# element:
+#
+# *   If the #begin element is an Integer, the #size method returns an Integer
+#     or `Float::INFINITY`.
+# *   If the #begin element is an object with a #succ method (other than
+#     Integer), #size returns `nil`. (Computing the size would require
+#     repeatedly calling #succ, which may be too slow.)
+# *   If the #begin element does not have a #succ method, #size raises a
+#     TypeError.
+#
+# Examples:
+#
+#     (10..42).each.size #=> 33
+#     (10..42.9).each.size #=> 33 (the #end element may be a non-integer numeric)
+#     (10..).each.size #=> Float::INFINITY
+#     ("a".."z").each.size #=> nil
+#     ("a"..).each.size #=> nil
+#     (1.0..9.0).each.size # raises TypeError (Float does not have #succ)
+#     (..10).each.size # raises TypeError (beginless range has nil as its #begin)
+#
+# The Enumerable module itself does not define a #size method. A class that
+# includes Enumerable may define its own #size method. It is recommended that
+# such a #size method be consistent with Enumerator#size.
+#
+# Array and Hash implement #size and return values consistent with
+# Enumerator#size. IO and Dir do not define #size, which is also consistent
+# because the corresponding enumerator's size function returns `nil`.
+#
+# However, it is not strictly required for a class's #size method to match
+# Enumerator#size. For example, File#size returns the number of bytes in the
+# file, not the number of lines.
+#
 module Enumerable[unchecked out Elem] : _Each[Elem]
   # <!--
   #   rdoc-file=enum.c
@@ -438,6 +514,17 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
+  #     e = (1..4).drop_while
+  #     p e #=> #<Enumerator: 1..4:drop_while>
+  #     i = e.next; p i; e.feed(i < 3) #=> 1
+  #     i = e.next; p i; e.feed(i < 3) #=> 2
+  #     i = e.next; p i; e.feed(i < 3) #=> 3
+  #     begin
+  #       e.next
+  #     rescue StopIteration
+  #       p $!.result #=> [3, 4]
+  #     end
+  #
   def drop_while: () { (Elem) -> boolish } -> ::Array[Elem]
                 | () -> ::Enumerator[Elem, ::Array[Elem]]
 

data/core/errno.rbs

@@ -38,6 +38,14 @@
 #     Errno::ENOENT::Errno      # => 2
 #     Errno::ENOTCAPABLE::Errno # => 0
 #
+# Each class in Errno can be created with optional messages:
+#
+#     Errno::EPIPE.new                  # => #<Errno::EPIPE: Broken pipe>
+#     Errno::EPIPE.new("foo")           # => #<Errno::EPIPE: Broken pipe - foo>
+#     Errno::EPIPE.new("foo", "here")   # => #<Errno::EPIPE: Broken pipe @ here - foo>
+#
+# See SystemCallError.new.
+#
 module Errno
   class NOERROR < SystemCallError
     Errno: 0

data/core/errors.rbs

@@ -302,9 +302,15 @@ class NameError[T] < StandardError
   def receiver: () -> T?
 end
 
+# <!-- rdoc-file=error.c -->
+# Raised when matching pattern not found.
+#
 class NoMatchingPatternError < StandardError
 end
 
+# <!-- rdoc-file=error.c -->
+# Raised when matching key not found.
+#
 class NoMatchingPatternKeyError[M, K] < NoMatchingPatternError
   # <!--
   #   rdoc-file=error.c
@@ -588,13 +594,34 @@ end
 class SystemCallError < StandardError
   # <!--
   #   rdoc-file=error.c
-  #   - SystemCallError.new(msg, errno)  -> system_call_error_subclass
+  #   - SystemCallError.new(msg, errno = nil, func = nil)  -> system_call_error_subclass
   # -->
   # If *errno* corresponds to a known system error code, constructs the
   # appropriate Errno class for that error, otherwise constructs a generic
   # SystemCallError object. The error number is subsequently available via the
   # #errno method.
   #
+  # If only numeric object is given, it is treated as an Integer *errno*, and
+  # *msg* is omitted, otherwise the first argument *msg* is used as the additional
+  # error message.
+  #
+  #     SystemCallError.new(Errno::EPIPE::Errno)
+  #     #=> #<Errno::EPIPE: Broken pipe>
+  #
+  #     SystemCallError.new("foo")
+  #     #=> #<SystemCallError: unknown error - foo>
+  #
+  #     SystemCallError.new("foo", Errno::EPIPE::Errno)
+  #     #=> #<Errno::EPIPE: Broken pipe - foo>
+  #
+  # If *func* is not `nil`, it is appended to the message with "` @ `".
+  #
+  #     SystemCallError.new("foo", Errno::EPIPE::Errno, "here")
+  #     #=> #<Errno::EPIPE: Broken pipe @ here - foo>
+  #
+  # A subclass of SystemCallError can also be instantiated via the `new` method of
+  # the subclass.  See Errno.
+  #
   def initialize: (string msg, Integer errno) -> void
 
   # <!--

data/core/exception.rbs

@@ -118,7 +118,7 @@ class Exception
   #       # String
   #     end
   #
-  # The value returned by this method migth be adjusted when raising (see
+  # The value returned by this method might be adjusted when raising (see
   # Kernel#raise), or during intermediate handling by #set_backtrace.
   #
   # See also #backtrace_locations that provide the same value, as structured
@@ -447,7 +447,7 @@ class Exception
   #     *   If the value of keyword `order` is `:top` (the default), lists the
   #         error message and the innermost backtrace entry first.
   #     *   If the value of keyword `order` is `:bottom`, lists the error message
-  #         the the innermost entry last.
+  #         the innermost entry last.
   #
   # Example:
   #

data/core/fiber.rbs

@@ -58,7 +58,7 @@
 # ## Non-blocking Fibers
 #
 # The concept of *non-blocking fiber* was introduced in Ruby 3.0. A non-blocking
-# fiber, when reaching a operation that would normally block the fiber (like
+# fiber, when reaching an operation that would normally block the fiber (like
 # `sleep`, or wait for another process or I/O) will yield control to other
 # fibers and allow the *scheduler* to handle blocking and waking up (resuming)
 # this fiber when it can proceed.
@@ -414,8 +414,8 @@ class Fiber < Object
   #
   # See Kernel#raise for more information.
   #
-  def raise: (?string msg) -> untyped
-           | (_Exception, ?string msg, ?Array[string] | Array[Thread::Backtrace::Location] | nil backtrace) -> untyped
+  def raise: (?string msg, ?cause: Exception?) -> untyped
+           | (_Exception, ?string msg, ?Array[string] | Array[Thread::Backtrace::Location] | nil backtrace, ?cause: Exception?) -> untyped
 
   # <!--
   #   rdoc-file=cont.c

data/core/file.rbs

@@ -1427,8 +1427,25 @@ class File < IO
   # -->
   # Returns the string representation of the path
   #
-  #     File.path(File::NULL)           #=> "/dev/null"
-  #     File.path(Pathname.new("/tmp")) #=> "/tmp"
+  #        File.path(File::NULL)           #=> "/dev/null"
+  #        File.path(Pathname.new("/tmp")) #=> "/tmp"
+  #
+  # If `path` is not a String:
+  #
+  # 1.  If it has the `to_path` method, that method will be called to coerce to a
+  #     String.
+  #
+  # 2.  Otherwise, or if the coerced result is not a String too, the standard
+  #     coersion using `to_str` method will take place on that object. (See also
+  #     String.try_convert)
+  #
+  # The coerced string must satisfy the following conditions:
+  #
+  # 1.  It must be in an ASCII-compatible encoding; otherwise, an
+  #     Encoding::CompatibilityError is raised.
+  #
+  # 2.  It must not contain the NUL character (`\0`); otherwise, an ArgumentError
+  #     is raised.
   #
   def self.path: (string | _ToPath path) -> String
 
@@ -1822,12 +1839,12 @@ class File < IO
   # Returns `false` if `File::LOCK_NB` is specified and the operation would have
   # blocked;
   # otherwise returns `0`.
-  #    Constant    |    Lock    |                                                    Effect
-  # ---------------|------------|--------------------------------------------------------------------------------------------------------------
-  # +File::LOCK_EX+| Exclusive  |                      Only one process may hold an exclusive lock for +self+ at a time.
-  # +File::LOCK_NB+|Non-blocking|No blocking; may be combined with +File::LOCK_SH+ or +File::LOCK_EX+ using the bitwise OR operator <tt>|</tt>.
-  # +File::LOCK_SH+|   Shared   |                 Multiple processes may each hold a shared lock for +self+ at the same time.
-  # +File::LOCK_UN+|   Unlock   |                                Remove an existing lock held by this process.
+  #    Constant    |    Lock    |                                                Effect
+  # ---------------|------------|-------------------------------------------------------------------------------------------------------
+  # `File::LOCK_EX`| Exclusive  |                   Only one process may hold an exclusive lock for `self` at a time.
+  # `File::LOCK_NB`|Non-blocking|No blocking; may be combined with `File::LOCK_SH` or `File::LOCK_EX` using the bitwise OR operator `|`.
+  # `File::LOCK_SH`|   Shared   |              Multiple processes may each hold a shared lock for `self` at the same time.
+  # `File::LOCK_UN`|   Unlock   |                             Remove an existing lock held by this process.
   # Example:
   #     # Update a counter using an exclusive lock.
   # # Don't use File::WRONLY because it truncates the file.
@@ -2429,10 +2446,8 @@ class File::Stat < Object
 
   # <!--
   #   rdoc-file=file.c
-  #   - new(p1)
+  #   - File::Stat.new(file_name)  -> stat
   # -->
-  # File::Stat.new(file_name)  -> stat
-  #
   # Create a File::Stat object for the given file name (raising an exception if
   # the file doesn't exist).
   #

data/core/float.rbs

@@ -1094,7 +1094,7 @@ Float::MAX_EXP: Integer
 # Usually defaults to 2.2250738585072014e-308.
 #
 # If the platform supports denormalized numbers, there are numbers between zero
-# and Float::MIN. 0.0.next_float returns the smallest positive floating point
+# and Float::MIN. `0.0.next_float` returns the smallest positive floating point
 # number including denormalized numbers.
 #
 Float::MIN: Float