rbs 3.10.2 → 4.0.0.dev.1

data/core/struct.rbs

@@ -130,7 +130,7 @@ class Struct[Elem]
   #     Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
   #     f = Foo.new(0, 1)                   # => #<struct Struct::Foo foo=0, bar=1>
   #
-  # **Class Name**
+  # **\Class Name**
   #
   # With string argument `class_name`, returns a new subclass of `Struct` named
   # `Struct::*class_name`*:

data/core/symbol.rbs

@@ -130,25 +130,19 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - self <=> other -> -1, 0, 1, or nil
+  #   - symbol <=> object -> -1, 0, +1, or nil
   # -->
-  # Compares `self` and `other`, using String#<=>.
+  # If `object` is a symbol, returns the equivalent of `symbol.to_s <=>
+  # object.to_s`:
   #
-  # Returns:
+  #     :bar <=> :foo # => -1
+  #     :foo <=> :foo # => 0
+  #     :foo <=> :bar # => 1
   #
-  # *   `self.to_s <=> other.to_s`, if `other` is a symbol.
-  # *   `nil`, otherwise.
+  # Otherwise, returns `nil`:
   #
-  # Examples:
-  #
-  #     :bar <=> :foo  # => -1
-  #     :foo <=> :foo  # => 0
-  #     :foo <=> :bar  # => 1
   #     :foo <=> 'bar' # => nil
   #
-  # Class Symbol includes module Comparable, each of whose methods uses Symbol#<=>
-  # for comparison.
-  #
   # Related: String#<=>.
   #
   def <=>: (Symbol object) -> (-1 | 0 | 1)
@@ -194,7 +188,7 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - capitalize(mapping) -> symbol
+  #   - capitalize(*options) -> symbol
   # -->
   # Equivalent to `sym.to_s.capitalize.to_sym`.
   #
@@ -274,7 +268,7 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - downcase(mapping) -> symbol
+  #   - downcase(*options) -> symbol
   # -->
   # Equivalent to `sym.to_s.downcase.to_sym`.
   #
@@ -419,7 +413,7 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - swapcase(mapping) -> symbol
+  #   - swapcase(*options) -> symbol
   # -->
   # Equivalent to `sym.to_s.swapcase.to_sym`.
   #
@@ -468,7 +462,7 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - upcase(mapping) -> symbol
+  #   - upcase(*options) -> symbol
   # -->
   # Equivalent to `sym.to_s.upcase.to_sym`.
   #

data/core/thread.rbs

@@ -265,10 +265,7 @@ class Thread < Object
   # -->
   # Terminates `thr` and schedules another thread to be run, returning the
   # terminated Thread.  If this is the main thread, or the last thread, exits the
-  # process. Note that the caller does not wait for the thread to terminate if the
-  # receiver is different from the currently running thread. The termination is
-  # asynchronous, and the thread can still run a small amount of ruby code before
-  # exiting.
+  # process.
   #
   def kill: () -> Thread?
 
@@ -337,10 +334,7 @@ class Thread < Object
   # <!-- rdoc-file=thread.c -->
   # Terminates `thr` and schedules another thread to be run, returning the
   # terminated Thread.  If this is the main thread, or the last thread, exits the
-  # process. Note that the caller does not wait for the thread to terminate if the
-  # receiver is different from the currently running thread. The termination is
-  # asynchronous, and the thread can still run a small amount of ruby code before
-  # exiting.
+  # process.
   #
   def exit: () -> Thread?
 
@@ -370,9 +364,9 @@ class Thread < Object
 
   # <!--
   #   rdoc-file=thread.c
-  #   - Thread.new { ... }                -> thread
-  #   - Thread.new(*args, &proc)          -> thread
-  #   - Thread.new(*args) { |args| ... }  -> thread
+  #   - Thread.new { ... }                  -> thread
+  #   - Thread.new(*args, &proc)            -> thread
+  #   - Thread.new(*args) { |args| ... }    -> thread
   # -->
   # Creates a new thread executing the given block.
   #
@@ -666,10 +660,7 @@ class Thread < Object
   # <!-- rdoc-file=thread.c -->
   # Terminates `thr` and schedules another thread to be run, returning the
   # terminated Thread.  If this is the main thread, or the last thread, exits the
-  # process. Note that the caller does not wait for the thread to terminate if the
-  # receiver is different from the currently running thread. The termination is
-  # asynchronous, and the thread can still run a small amount of ruby code before
-  # exiting.
+  # process.
   #
   def terminate: () -> Thread?
 
@@ -963,11 +954,12 @@ class Thread < Object
 
   # <!--
   #   rdoc-file=thread.c
-  #   - raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
-  #   - raise(message = nil, cause: $!)
+  #   - thr.raise
+  #   - thr.raise(string)
+  #   - thr.raise(exception [, string [, array]])
   # -->
   # Raises an exception from the given thread. The caller does not have to be
-  # `thr`. See Kernel#raise for more information on arguments.
+  # `thr`. See Kernel#raise for more information.
   #
   #     Thread.abort_on_exception = true
   #     a = Thread.new { sleep(200) }
@@ -980,8 +972,8 @@ class Thread < Object
   #      from prog.rb:2:in `new'
   #      from prog.rb:2
   #
-  def raise: (?String message, ?cause: Exception?) -> nil
-           | (_Exception, ?_ToS message, ?Array[Thread::Backtrace::Location] | Array[String] | nil backtrace, ?cause: Exception?) -> nil
+  def raise: (?String message) -> nil
+           | (_Exception, ?_ToS message, ?Array[Thread::Backtrace::Location] | Array[String] | nil backtrace) -> nil
 
   # <!--
   #   rdoc-file=thread.c
@@ -1393,80 +1385,28 @@ end
 # <!-- rdoc-file=thread_sync.c -->
 # ConditionVariable objects augment class Mutex. Using condition variables, it
 # is possible to suspend while in the middle of a critical section until a
-# condition is met, such as a resource becomes available.
-#
-# Due to non-deterministic scheduling and spurious wake-ups, users of condition
-# variables should always use a separate boolean predicate (such as reading from
-# a boolean variable) to check if the condition is actually met before starting
-# to wait, and should wait in a loop, re-checking the condition every time the
-# ConditionVariable is waken up.  The idiomatic way of using condition variables
-# is calling the `wait` method in an `until` loop with the predicate as the loop
-# condition.
-#
-#     condvar.wait(mutex) until condition_is_met
-#
-# In the example below, we use the boolean variable `resource_available` (which
-# is protected by `mutex`) to indicate the availability of the resource, and use
-# `condvar` to wait for that variable to become true.  Note that:
-#
-# 1.  Thread `b` may be scheduled before thread `a1` and `a2`, and may run so
-#     fast that it have already made the resource available before either `a1`
-#     or `a2` starts. Therefore, `a1` and `a2` should check if
-#     `resource_available` is already true before starting to wait.
-# 2.  The `wait` method may spuriously wake up without signalling. Therefore,
-#     thread `a1` and `a2` should recheck `resource_available` after the `wait`
-#     method returns, and go back to wait if the condition is not actually met.
-# 3.  It is possible that thread `a2` starts right after thread `a1` is waken up
-#     by `b`.  Thread `a2` may have acquired the `mutex` and consumed the
-#     resource before thread `a1` acquires the `mutex`.  This necessitates
-#     rechecking after `wait`, too.
+# resource becomes available.
 #
 # Example:
 #
 #     mutex = Thread::Mutex.new
+#     resource = Thread::ConditionVariable.new
 #
-#     resource_available = false
-#     condvar = Thread::ConditionVariable.new
-#
-#     a1 = Thread.new {
-#       # Thread 'a1' waits for the resource to become available and consumes
-#       # the resource.
-#       mutex.synchronize {
-#         condvar.wait(mutex) until resource_available
-#         # After the loop, 'resource_available' is guaranteed to be true.
-#
-#         resource_available = false
-#         puts "a1 consumed the resource"
-#       }
-#     }
-#
-#     a2 = Thread.new {
-#       # Thread 'a2' behaves like 'a1'.
-#       mutex.synchronize {
-#         condvar.wait(mutex) until resource_available
-#         resource_available = false
-#         puts "a2 consumed the resource"
-#       }
+#     a = Thread.new {
+#        mutex.synchronize {
+#          # Thread 'a' now needs the resource
+#          resource.wait(mutex)
+#          # 'a' can now have the resource
+#        }
 #     }
 #
 #     b = Thread.new {
-#       # Thread 'b' periodically makes the resource available.
-#       loop {
-#         mutex.synchronize {
-#           resource_available = true
-#
-#           # Notify one waiting thread if any.  It is possible that neither
-#           # 'a1' nor 'a2 is waiting on 'condvar' at this moment.  That's OK.
-#           condvar.signal
-#         }
-#         sleep 1
-#       }
+#        mutex.synchronize {
+#          # Thread 'b' has finished using the resource
+#          resource.signal
+#        }
 #     }
 #
-#     # Eventually both 'a1' and 'a2' will have their resources, albeit in an
-#     # unspecified order.
-#     [a1, a2].each {|th| th.join}
-#
 class Thread::ConditionVariable < Object
   # <!--
   #   rdoc-file=thread_sync.c
@@ -1493,8 +1433,6 @@ class Thread::ConditionVariable < Object
   # If `timeout` is given, this method returns after `timeout` seconds passed,
   # even if no other thread doesn't signal.
   #
-  # This method may wake up spuriously due to underlying implementation details.
-  #
   # Returns the slept result on `mutex`.
   #
   def wait: (Thread::Mutex mutex, ?Time::_Timeout? timeout) -> Integer?
@@ -1522,7 +1460,7 @@ end
 #
 class Thread::Mutex < Object
   # <!--
-  #   rdoc-file=thread_sync.rb
+  #   rdoc-file=thread_sync.c
   #   - mutex.lock  -> self
   # -->
   # Attempts to grab the lock and waits if it isn't available. Raises
@@ -1531,7 +1469,7 @@ class Thread::Mutex < Object
   def lock: () -> self
 
   # <!--
-  #   rdoc-file=thread_sync.rb
+  #   rdoc-file=thread_sync.c
   #   - mutex.locked?  -> true or false
   # -->
   # Returns `true` if this lock is currently held by some thread.
@@ -1539,7 +1477,7 @@ class Thread::Mutex < Object
   def locked?: () -> bool
 
   # <!--
-  #   rdoc-file=thread_sync.rb
+  #   rdoc-file=thread_sync.c
   #   - mutex.owned?  -> true or false
   # -->
   # Returns `true` if this lock is currently held by current thread.
@@ -1547,7 +1485,7 @@ class Thread::Mutex < Object
   def owned?: () -> bool
 
   # <!--
-  #   rdoc-file=thread_sync.rb
+  #   rdoc-file=thread_sync.c
   #   - mutex.synchronize { ... }    -> result of the block
   # -->
   # Obtains a lock, runs the block, and releases the lock when the block
@@ -1556,7 +1494,7 @@ class Thread::Mutex < Object
   def synchronize: [X] () { () -> X } -> X
 
   # <!--
-  #   rdoc-file=thread_sync.rb
+  #   rdoc-file=thread_sync.c
   #   - mutex.try_lock  -> true or false
   # -->
   # Attempts to obtain the lock and returns immediately. Returns `true` if the
@@ -1565,11 +1503,11 @@ class Thread::Mutex < Object
   def try_lock: () -> bool
 
   # <!--
-  #   rdoc-file=thread_sync.rb
-  #   - mutex.lock  -> self
+  #   rdoc-file=thread_sync.c
+  #   - mutex.unlock    -> self
   # -->
-  # Attempts to grab the lock and waits if it isn't available. Raises
-  # `ThreadError` if `mutex` was locked by the current thread.
+  # Releases the lock. Raises `ThreadError` if `mutex` wasn't locked by the
+  # current thread.
   #
   def unlock: () -> self
 end

data/core/time.rbs

@@ -47,30 +47,24 @@
 #
 # ## Time Internal Representation
 #
-# Conceptually, Time class uses a rational value to represent the number of
-# seconds from *Epoch*, 1970-01-01 00:00:00 UTC. There are no boundary or
-# resolution limitations. The value can be obtained using Time#to_r.
-#
-# The Time class always uses the Gregorian calendar. I.e. the proleptic
-# Gregorian calendar is used. Other calendars, such as Julian calendar, are not
-# supported.
-#
-# The implementation uses a signed 63 bit integer, Integer (Bignum) object or
-# Ratoinal object to represent a rational value. (The signed 63 bit integer is
-# used regardless of 32 and 64 bit environments.) The value represents the
-# number of nanoseconds from *Epoch*. The signed 63 bit integer can represent
-# 1823-11-12 to 2116-02-20. When Integer or Rational object is used (before
+# Time implementation uses a signed 63 bit integer, Integer, or Rational. It is
+# a number of nanoseconds since the *Epoch*. The signed 63 bit integer can
+# represent 1823-11-12 to 2116-02-20. When Integer or Rational is used (before
 # 1823, after 2116, under nanosecond), Time works slower than when the signed 63
 # bit integer is used.
 #
 # Ruby uses the C function `localtime` and `gmtime` to map between the number
 # and 6-tuple (year,month,day,hour,minute,second). `localtime` is used for local
-# time and `gmtime` is used for UTC.
+# time and "gmtime" is used for UTC.
 #
 # Integer and Rational has no range limit, but the localtime and gmtime has
 # range limits due to the C types `time_t` and `struct tm`. If that limit is
 # exceeded, Ruby extrapolates the localtime function.
 #
+# The Time class always uses the Gregorian calendar. I.e. the proleptic
+# Gregorian calendar is used. Other calendars, such as Julian calendar, are not
+# supported.
+#
 # `time_t` can represent 1901-12-14 to 2038-01-19 if it is 32 bit signed
 # integer, -292277022657-01-27 to 292277026596-12-05 if it is 64 bit signed
 # integer. However `localtime` on some platforms doesn't supports negative
@@ -78,7 +72,7 @@
 #
 # `struct tm` has *tm_year* member to represent years. (`tm_year = 0` means the
 # year 1900.) It is defined as `int` in the C standard. *tm_year* can represent
-# years between -2147481748 to 2147485547 if `int` is 32 bit.
+# between -2147481748 to 2147485547 if `int` is 32 bit.
 #
 # Ruby supports leap seconds as far as if the C function `localtime` and
 # `gmtime` supports it. They use the tz database in most Unix systems. The tz
@@ -990,20 +984,10 @@ class Time < Object
   #     now = Time.now
   #     # => 2022-08-18 10:24:13.5398485 -0500
   #     now.utc? # => false
-  #     now.getutc.utc? # => true
   #     utc = Time.utc(2000, 1, 1, 20, 15, 1)
   #     # => 2000-01-01 20:15:01 UTC
   #     utc.utc? # => true
   #
-  # `Time` objects created with these methods are considered to be in UTC:
-  #
-  # *   Time.utc
-  # *   Time#utc
-  # *   Time#getutc
-  #
-  # Objects created in other ways will not be treated as UTC even if the
-  # environment variable "TZ" is "UTC".
-  #
   # Related: Time.utc.
   #
   def gmt?: () -> bool
@@ -1576,20 +1560,10 @@ class Time < Object
   #     now = Time.now
   #     # => 2022-08-18 10:24:13.5398485 -0500
   #     now.utc? # => false
-  #     now.getutc.utc? # => true
   #     utc = Time.utc(2000, 1, 1, 20, 15, 1)
   #     # => 2000-01-01 20:15:01 UTC
   #     utc.utc? # => true
   #
-  # `Time` objects created with these methods are considered to be in UTC:
-  #
-  # *   Time.utc
-  # *   Time#utc
-  # *   Time#getutc
-  #
-  # Objects created in other ways will not be treated as UTC even if the
-  # environment variable "TZ" is "UTC".
-  #
   # Related: Time.utc.
   #
   def utc?: () -> bool

data/core/trace_point.rbs

@@ -25,8 +25,7 @@
 # change. Instead, it is recommended to specify the types of events you want to
 # use.
 #
-# To filter what is traced, you can pass any number of the following as
-# `events`:
+# To filter what is traced, you can pass any of the following as `events`:
 #
 # `:line`
 # :   Execute an expression or statement on a new line.
@@ -108,8 +107,8 @@ class TracePoint
   #
   # A block must be given; otherwise, an ArgumentError is raised.
   #
-  # If the trace method isn't supported for the given event(s) filter, a
-  # RuntimeError is raised.
+  # If the trace method isn't included in the given events filter, a RuntimeError
+  # is raised.
   #
   #     TracePoint.trace(:line) do |tp|
   #       p tp.raised_exception
@@ -123,9 +122,7 @@ class TracePoint
   #     end
   #     $tp.lineno #=> access from outside (RuntimeError)
   #
-  # Access from other ractors, threads or fibers is forbidden. TracePoints are
-  # active per-ractor so if you enable a TracePoint in one ractor, other ractors
-  # will not be affected.
+  # Access from other threads is also forbidden.
   #
   def self.new: (*_ToSym events) { (instance tp) -> void } -> instance
 

data/core/unbound_method.rbs

@@ -1,5 +1,5 @@
 # <!-- rdoc-file=proc.c -->
-# Ruby supports two forms of objectified methods. Class `Method` is used to
+# Ruby supports two forms of objectified methods. Class Method is used to
 # represent methods that are associated with a particular object: these method
 # objects are bound to that object. Bound method objects for an object can be
 # created using Object#method.
@@ -287,18 +287,10 @@ class UnboundMethod
 
   # <!--
   #   rdoc-file=proc.c
-  #   - meth.source_location  -> [String, Integer, Integer, Integer, Integer]
+  #   - meth.source_location  -> [String, Integer]
   # -->
-  # Returns the location where the method 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 method was not defined in Ruby (i.e.
-  # native).
+  # Returns the Ruby source filename and line number containing this method or nil
+  # if this method was not defined in Ruby (i.e. native).
   #
   def source_location: () -> [String, Integer]?
 
@@ -306,8 +298,8 @@ class UnboundMethod
   #   rdoc-file=proc.c
   #   - meth.super_method  -> method
   # -->
-  # Returns a `Method` of superclass which would be called when super is used or
-  # nil if there is no method on superclass.
+  # Returns a Method of superclass which would be called when super is used or nil
+  # if there is no method on superclass.
   #
   def super_method: () -> UnboundMethod?
 

data/docs/collection.md

@@ -159,9 +159,9 @@ For example:
 # manifest.yaml
 
 dependencies:
-  # If your gem depends on logger but the gemspec doesn't include logger,
+  # If your gem depends on pathname but the gemspec doesn't include pathname,
   # you need to write the following.
-  - name: logger
+  - name: pathname
 ```
 
 If the gem's RBS is managed with [ruby/gem_rbs_collection](https://github.com/ruby/gem_rbs_collection), put it as `gems/GEM_NAME/VERSION/manifest.yaml`.  For example, `gems/activesupport/6.0/manifest.yaml`.

data/docs/gem.md

@@ -34,6 +34,7 @@ dependencies:
   - name: json
   - name: logger
   - name: optparse
+  - name: pathname
   - name: rdoc
   - name: tsort
 ```

data/docs/sigs.md

@@ -131,10 +131,10 @@ You may need to specify `-r` or `-I` to load signatures.
 The default is `-I sig`.
 
 ```shell
-RBS_TEST_OPT='-r logger -I sig'
+RBS_TEST_OPT='-r pathname -I sig'
 ```
 
-Replacing `logger` with the `stdlib` you want to include. For example, if you need to load `Set` and `BigDecimal` in `stdlib`, you would need to have `RBS_TEST_OPT='-r set -r bigdecimal -I sig'`
+Replacing `pathname` with the `stdlib` you want to include. For example, if you need to load `Set` and `BigDecimal` in `stdlib`, you would need to have `RBS_TEST_OPT='-r set -r bigdecimal -I sig'`
 
 `RBS_TEST_LOGLEVEL` can be used to configure log level. Defaults to `info`.
 
@@ -148,7 +148,7 @@ So, a typical command line to start the test would look like the following:
 $ RBS_TEST_LOGLEVEL=error \
   RBS_TEST_TARGET='Kaigi::*' \
   RBS_TEST_SKIP='Kaigi::MonkeyPatch' \
-  RBS_TEST_OPT='-rlogger -Isig -Iprivate' \
+  RBS_TEST_OPT='-rset -rpathname -Isig -Iprivate' \
   RBS_TEST_RAISE=true \
   RUBYOPT='-rbundler/setup -rrbs/test/setup' \
   bundle exec rake test