rbs 2.6.0 → 2.7.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7c0492a40dd2d8ce395ddb823807f2a33d76646a5a63edbbed4fbae0c924e28
-  data.tar.gz: 66f2ea0d8fa7982274b687d3d27146db1cded7f45ecce88ed5a320cdbd1b125a
+  metadata.gz: aeae92c94238c9c1b417f2efd334c6af1435c94b6f43480f6979b413694936b4
+  data.tar.gz: 8abf8d32d6ce0b2103696436698fe5687bef05a677da6f46a317f83adfe73380
 SHA512:
-  metadata.gz: 49dc3f14f20efc27a4eb590d36af44e2565dfdc20061260336b6ed2ae88784d5f759759ff602b3ba88c402df110ee13c9d198caa75b7153dafc3938c6df776ea
-  data.tar.gz: d4659a14549a0fd7686b8a9e0c8bd7433d688e9470e26780785bb9c627625fc2ac32332298f6d7dc1442316dd6eb439a7c4c0bd99f28c6fbd2cab50698b3d9d3
+  metadata.gz: 6bdb78cad95578cf94728625e0d20ca211a1ed8140a728f5f723b2331731733d73bc6d33e0ec4f914782ff1cde52d52079c5625afe008a297c1952b115870075
+  data.tar.gz: 0c56b8f9ce630cc77ec080ca5ad172611005fb2cd6cfcc18ea239dc5a8490aa11f74a0f4bd9d3045a8e71f6920b41d203fb7d228207696ea92d0c74c9069b317

data/.gitignore

@@ -18,3 +18,5 @@
 lib/**/*.bundle
 lib/**/*.so
 lib/**/*.dll
+doc/
+**/*.gem

data/.rubocop.yml

@@ -13,3 +13,8 @@ Lint/DuplicateMethods:
   Enabled: true
   Include:
     - 'test/**/*_test.rb'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  Include:
+    - 'lib/**/*.rb'

data/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## master
 
+## 2.7.0.pre.1 (2022-09-02)
+
+See [Release Note 2.7](https://github.com/ruby/rbs/wiki/Release-Note-2.7) for the highlights of this release.
+
+### Signature updates
+
+* fiber ([#1071](https://github.com/ruby/rbs/pull/1071))
+* `BigDecimal` ([#1053](https://github.com/ruby/rbs/pull/1053))
+* `ERB::Util`, `ERB::DefMethod` ([#1074](https://github.com/ruby/rbs/pull/1074))
+* `Float::Infinity` ([#1095](https://github.com/ruby/rbs/pull/1095))
+* `Logger` ([#1046](https://github.com/ruby/rbs/pull/1046))
+* `IO.pipe`, `IO.foreach` ([#1057](https://github.com/ruby/rbs/pull/1057))
+* `Module#refine` ([#1064](https://github.com/ruby/rbs/pull/1064))
+* `Regexp.new` ([#1059](https://github.com/ruby/rbs/pull/1059))
+* `StringIO#write` ([#1065](https://github.com/ruby/rbs/pull/1065))
+* `Warning.#warn`, `Kernel.#warn` ([#1056](https://github.com/ruby/rbs/pull/1056))
+
+### Language updates
+
+* Type of `self` in blocks/procs ([#1077](https://github.com/ruby/rbs/issues/1077), [#1101](https://github.com/ruby/rbs/pull/1101))
+
+### Library changes
+
+* RDoc plugin ([#1048](https://github.com/ruby/rbs/pull/1048))
+* Dedupe method comments ([#1103](https://github.com/ruby/rbs/pull/1103))
+* Reduce object allocations for GC ([#1102](https://github.com/ruby/rbs/pull/1102))
+* Add `frozen_string_literal: true` ([#1100](https://github.com/ruby/rbs/pull/1100))
+* Load dependencies on `-r` option also ([#1013](https://github.com/ruby/rbs/pull/1013))
+* Fix DefinitionBuilder for methods aliased from module self constraints ([#1099](https://github.com/ruby/rbs/pull/1099))
+* Fix RBS type definitions ([#1098](https://github.com/ruby/rbs/pull/1098))
+* Give aliases of `.new` methods correct type ([#1097](https://github.com/ruby/rbs/pull/1097))
+* `nil` versions are discouraged and will be deprecated in Rubygems 4 ([#1091](https://github.com/ruby/rbs/pull/1091))
+* Fixes towards Rubygems 4.0 ([#1090](https://github.com/ruby/rbs/pull/1090))
+* Remove redundant `add` for `Repository.default` ([#1062](https://github.com/ruby/rbs/pull/1062))
+* Refactor: Use Repository in stdlib source ([#1063](https://github.com/ruby/rbs/pull/1063))
+* Move `bin/sort` implementation to under `lib/` ([#1051](https://github.com/ruby/rbs/pull/1051))
+
+#### rbs prototype
+
+* Fix some error on `prototype runtime` ([#1055](https://github.com/ruby/rbs/pull/1055))
+* Skip existing RBS files from batch `prototype` ([#1060](https://github.com/ruby/rbs/pull/1060))
+
+### Miscellaneous
+
+* Discard outputs from test code ([#1093](https://github.com/ruby/rbs/pull/1093))
+* Skip testing visibility methods with Ruby 3.2 ([#1082](https://github.com/ruby/rbs/pull/1082))
+
 ## 2.6.0 (2022-06-22)
 
 RBS 2.6 ships with `rbs prototype` commands improvements and signature updates.
@@ -44,7 +91,7 @@ New minitest RBS definitions will help you to type check your tests.
 * Fix type errors ([\#1023](https://github.com/ruby/rbs/pull/1023))
 * Clarify GHA step name for rake annotate ([\#1024](https://github.com/ruby/rbs/pull/1024))
 * Silence parser warning ([\#1039](https://github.com/ruby/rbs/pull/1039))
-* Fix warnings ([\#1035](https://github.com/ruby/rbs/pull/1035)
+* Fix warnings ([\#1035](https://github.com/ruby/rbs/pull/1035))
 
 ## 2.5.1 (2022-06-19)
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbs (2.6.0)
+    rbs (2.7.0.pre.1)
 
 PATH
   remote: test/assets/test-gem
@@ -30,9 +30,9 @@ GEM
     json-schema (3.0.0)
       addressable (>= 2.8)
     marcel (1.0.2)
-    minitest (5.16.1)
+    minitest (5.16.3)
     parallel (1.22.1)
-    parser (3.1.2.0)
+    parser (3.1.2.1)
       ast (~> 2.4.1)
     power_assert (2.0.1)
     prime (0.1.2)
@@ -62,16 +62,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    rubocop (1.30.1)
+    rubocop (1.35.1)
+      json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.0.0)
+      parser (>= 3.1.2.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.18.0, < 2.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.18.0)
+    rubocop-ast (1.21.0)
       parser (>= 3.1.1.0)
     rubocop-rubycw (0.1.6)
       rubocop (~> 1.0)
@@ -79,13 +80,13 @@ GEM
       rake (>= 0.8.1)
     ruby-progressbar (1.11.0)
     singleton (0.1.1)
-    stackprof (0.2.19)
+    stackprof (0.2.21)
     stringio (3.0.2)
     strong_json (2.1.2)
     tempfile (0.1.2)
     test-unit (3.5.3)
       power_assert
-    unicode-display_width (2.1.0)
+    unicode-display_width (2.2.0)
 
 PLATFORMS
   ruby

data/Rakefile

@@ -60,11 +60,6 @@ task :validate => :compile do
 
   FileList["stdlib/*"].each do |path|
     lib = [File.basename(path).to_s]
-    if File.exist?("#{path}/0/manifest.yaml")
-      YAML.load_file("#{path}/0/manifest.yaml")["dependencies"].each do |dep|
-        lib << dep["name"]
-      end
-    end
 
     sh "#{ruby} #{rbs} #{lib.map {|l| "-r #{l}"}.join(" ")} validate --silent"
   end

data/Steepfile

@@ -13,6 +13,7 @@ target :lib do
   signature "stdlib/strscan/0/"
   signature "stdlib/rubygems/0/"
   signature "stdlib/optparse/0/"
+  signature "stdlib/rdoc/0/"
 
   configure_code_diagnostics do |config|
     config[D::Ruby::MethodDefinitionMissing] = :hint

data/core/basic_object.rbs

@@ -257,7 +257,7 @@ class BasicObject
   #     k.instance_eval {|obj| obj == self } #=> true
   #
   def instance_eval: (String, ?String filename, ?Integer lineno) -> untyped
-                   | [U] () { (self) -> U } -> U
+                   | [U] () { (self) [self: self] -> U } -> U
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -276,7 +276,7 @@ class BasicObject
   #     k = KlassWithSecret.new
   #     k.instance_exec(5) {|x| @secret+x }   #=> 104
   #
-  def instance_exec: [U, V] (*V args) { (*V args) -> U } -> U
+  def instance_exec: [U, V] (*V args) { (*V args) [self: self] -> U } -> U
 
   # <!--
   #   rdoc-file=object.c

data/core/fiber.rbs

@@ -76,6 +76,114 @@
 # the scheduler.
 #
 class Fiber < Object
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.blocking? -> false or 1
+  # -->
+  # Returns `false` if the current fiber is non-blocking. Fiber is non-blocking if
+  # it was created via passing `blocking: false` to Fiber.new, or via
+  # Fiber.schedule.
+  #
+  # If the current Fiber is blocking, the method returns 1. Future developments
+  # may allow for situations where larger integers could be returned.
+  #
+  # Note that, even if the method returns `false`, Fiber behaves differently only
+  # if Fiber.scheduler is set in the current thread.
+  #
+  # See the "Non-blocking fibers" section in class docs for details.
+  #
+  def self.blocking?: () -> untyped
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.current -> fiber
+  # -->
+  # Returns the current fiber. If you are not running in the context of a fiber
+  # this method will return the root fiber.
+  #
+  def self.current: () -> Fiber
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.current_scheduler -> obj or nil
+  # -->
+  # Returns the Fiber scheduler, that was last set for the current thread with
+  # Fiber.set_scheduler if and only if the current fiber is non-blocking.
+  #
+  def self.current_scheduler: () -> untyped?
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.schedule { |*args| ... } -> fiber
+  # -->
+  # The method is *expected* to immediately run the provided block of code in a
+  # separate non-blocking fiber.
+  #
+  #     puts "Go to sleep!"
+  #
+  #     Fiber.set_scheduler(MyScheduler.new)
+  #
+  #     Fiber.schedule do
+  #       puts "Going to sleep"
+  #       sleep(1)
+  #       puts "I slept well"
+  #     end
+  #
+  #     puts "Wakey-wakey, sleepyhead"
+  #
+  # Assuming MyScheduler is properly implemented, this program will produce:
+  #
+  #     Go to sleep!
+  #     Going to sleep
+  #     Wakey-wakey, sleepyhead
+  #     ...1 sec pause here...
+  #     I slept well
+  #
+  # ...e.g. on the first blocking operation inside the Fiber (`sleep(1)`), the
+  # control is yielded to the outside code (main fiber), and *at the end of that
+  # execution*, the scheduler takes care of properly resuming all the blocked
+  # fibers.
+  #
+  # Note that the behavior described above is how the method is *expected* to
+  # behave, actual behavior is up to the current scheduler's implementation of
+  # Fiber::SchedulerInterface#fiber method. Ruby doesn't enforce this method to
+  # behave in any particular way.
+  #
+  # If the scheduler is not set, the method raises `RuntimeError (No scheduler is
+  # available!)`.
+  #
+  def self.schedule: () { () -> void } -> Fiber
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.scheduler -> obj or nil
+  # -->
+  # Returns the Fiber scheduler, that was last set for the current thread with Fiber.set_scheduler.
+  #     Returns +nil+ if no scheduler is set (which is the default), and non-blocking fibers'
+  #
+  # #  behavior is the same as blocking.
+  #     (see "Non-blocking fibers" section in class docs for details about the scheduler concept).
+  #
+  def self.scheduler: () -> untyped?
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - Fiber.set_scheduler(scheduler) -> scheduler
+  # -->
+  # Sets the Fiber scheduler for the current thread. If the scheduler is set,
+  # non-blocking fibers (created by Fiber.new with `blocking: false`, or by
+  # Fiber.schedule) call that scheduler's hook methods on potentially blocking
+  # operations, and the current thread will call scheduler's `close` method on
+  # finalization (allowing the scheduler to properly manage all non-finished
+  # fibers).
+  #
+  # `scheduler` can be an object of any class corresponding to
+  # Fiber::SchedulerInterface. Its implementation is up to the user.
+  #
+  # See also the "Non-blocking fibers" section in class docs.
+  #
+  def self.set_scheduler: (untyped) -> untyped
+
   # <!--
   #   rdoc-file=cont.c
   #   - Fiber.yield(args, ...) -> obj
@@ -85,7 +193,7 @@ class Fiber < Object
   # point when #resume is called next. Any arguments passed to the next #resume
   # will be the value that this Fiber.yield expression evaluates to.
   #
-  def self.yield: (*untyped args) -> untyped
+  def self.yield: (*untyped) -> untyped
 
   # <!--
   #   rdoc-file=cont.c
@@ -110,22 +218,106 @@ class Fiber < Object
   # Fiber.scheduler defined, the Fiber becomes non-blocking (see "Non-blocking
   # Fibers" section in class docs).
   #
-  def initialize: () { () -> untyped } -> void
+  def initialize: (?blocking: boolish) { (*untyped) -> void } -> void
 
   # <!--
   #   rdoc-file=cont.c
-  #   - fiber.resume(args, ...) -> obj
+  #   - fiber.alive? -> true or false
   # -->
-  # Resumes the fiber from the point at which the last Fiber.yield was called, or
-  # starts running it if it is the first call to #resume. Arguments passed to
-  # resume will be the value of the Fiber.yield expression or will be passed as
-  # block parameters to the fiber's block if this is the first #resume.
+  # Returns true if the fiber can still be resumed (or transferred to). After
+  # finishing execution of the fiber block this method will always return `false`.
   #
-  # Alternatively, when resume is called it evaluates to the arguments passed to
-  # the next Fiber.yield statement inside the fiber's block or to the block value
-  # if it runs to completion without any Fiber.yield
+  def alive?: () -> bool
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - fiber.backtrace -> array
+  #   - fiber.backtrace(start) -> array
+  #   - fiber.backtrace(start, count) -> array
+  #   - fiber.backtrace(start..end) -> array
+  # -->
+  # Returns the current execution stack of the fiber. `start`, `count` and `end`
+  # allow to select only parts of the backtrace.
+  #
+  #     def level3
+  #       Fiber.yield
+  #     end
   #
-  def resume: (*untyped args) -> untyped
+  #     def level2
+  #       level3
+  #     end
+  #
+  #     def level1
+  #       level2
+  #     end
+  #
+  #     f = Fiber.new { level1 }
+  #
+  #     # It is empty before the fiber started
+  #     f.backtrace
+  #     #=> []
+  #
+  #     f.resume
+  #
+  #     f.backtrace
+  #     #=> ["test.rb:2:in `yield'", "test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"]
+  #     p f.backtrace(1) # start from the item 1
+  #     #=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"]
+  #     p f.backtrace(2, 2) # start from item 2, take 2
+  #     #=> ["test.rb:6:in `level2'", "test.rb:10:in `level1'"]
+  #     p f.backtrace(1..3) # take items from 1 to 3
+  #     #=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'"]
+  #
+  #     f.resume
+  #
+  #     # It is nil after the fiber is finished
+  #     f.backtrace
+  #     #=> nil
+  #
+  def backtrace: (?Integer start, ?Integer count) -> Array[String]?
+               | (Range[Integer]) -> Array[String]?
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - fiber.backtrace_locations -> array
+  #   - fiber.backtrace_locations(start) -> array
+  #   - fiber.backtrace_locations(start, count) -> array
+  #   - fiber.backtrace_locations(start..end) -> array
+  # -->
+  # Like #backtrace, but returns each line of the execution stack as a
+  # Thread::Backtrace::Location. Accepts the same arguments as #backtrace.
+  #
+  #     f = Fiber.new { Fiber.yield }
+  #     f.resume
+  #     loc = f.backtrace_locations.first
+  #     loc.label  #=> "yield"
+  #     loc.path   #=> "test.rb"
+  #     loc.lineno #=> 1
+  #
+  def backtrace_locations: (?Integer start, ?Integer count) -> Array[Thread::Backtrace::Location]?
+                         | (Range[Integer]) -> Array[Thread::Backtrace::Location]?
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - fiber.blocking? -> true or false
+  # -->
+  # Returns `true` if `fiber` is blocking and `false` otherwise. Fiber is
+  # non-blocking if it was created via passing `blocking: false` to Fiber.new, or
+  # via Fiber.schedule.
+  #
+  # Note that, even if the method returns `false`, the fiber behaves differently
+  # only if Fiber.scheduler is set in the current thread.
+  #
+  # See the "Non-blocking fibers" section in class docs for details.
+  #
+  def blocking?: () -> bool
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - inspect()
+  # -->
+  #
+  alias inspect to_s
 
   # <!--
   #   rdoc-file=cont.c
@@ -147,7 +339,105 @@ class Fiber < Object
   # parameter is an array of callback information. Exceptions are caught by the
   # `rescue` clause of `begin...end` blocks.
   #
-  def raise: () -> untyped
-           | (string message) -> untyped
-           | (_Exception exception, ?string message, ?Array[String] backtrace) -> untyped
+  def raise: (?string msg) -> untyped
+           | (_Exception, ?string msg, ?Array[string] backtrace) -> untyped
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - fiber.resume(args, ...) -> obj
+  # -->
+  # Resumes the fiber from the point at which the last Fiber.yield was called, or
+  # starts running it if it is the first call to #resume. Arguments passed to
+  # resume will be the value of the Fiber.yield expression or will be passed as
+  # block parameters to the fiber's block if this is the first #resume.
+  #
+  # Alternatively, when resume is called it evaluates to the arguments passed to
+  # the next Fiber.yield statement inside the fiber's block or to the block value
+  # if it runs to completion without any Fiber.yield
+  #
+  def resume: (*untyped) -> untyped
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - to_s()
+  # -->
+  #
+  def to_s: () -> untyped
+
+  # <!--
+  #   rdoc-file=cont.c
+  #   - fiber.transfer(args, ...) -> obj
+  # -->
+  # Transfer control to another fiber, resuming it from where it last stopped or
+  # starting it if it was not resumed before. The calling fiber will be suspended
+  # much like in a call to Fiber.yield.
+  #
+  # The fiber which receives the transfer call treats it much like a resume call.
+  # Arguments passed to transfer are treated like those passed to resume.
+  #
+  # The two style of control passing to and from fiber (one is #resume and
+  # Fiber::yield, another is #transfer to and from fiber) can't be freely mixed.
+  #
+  # *   If the Fiber's lifecycle had started with transfer, it will never be able
+  #     to yield or be resumed control passing, only finish or transfer back. (It
+  #     still can resume other fibers that are allowed to be resumed.)
+  # *   If the Fiber's lifecycle had started with resume, it can yield or transfer
+  #     to another Fiber, but can receive control back only the way compatible
+  #     with the way it was given away: if it had transferred, it only can be
+  #     transferred back, and if it had yielded, it only can be resumed back.
+  #     After that, it again can transfer or yield.
+  #
+  #
+  # If those rules are broken FiberError is raised.
+  #
+  # For an individual Fiber design, yield/resume is easier to use (the Fiber just
+  # gives away control, it doesn't need to think about who the control is given
+  # to), while transfer is more flexible for complex cases, allowing to build
+  # arbitrary graphs of Fibers dependent on each other.
+  #
+  # Example:
+  #
+  #     manager = nil # For local var to be visible inside worker block
+  #
+  #     # This fiber would be started with transfer
+  #     # It can't yield, and can't be resumed
+  #     worker = Fiber.new { |work|
+  #       puts "Worker: starts"
+  #       puts "Worker: Performed #{work.inspect}, transferring back"
+  #       # Fiber.yield     # this would raise FiberError: attempt to yield on a not resumed fiber
+  #       # manager.resume  # this would raise FiberError: attempt to resume a resumed fiber (double resume)
+  #       manager.transfer(work.capitalize)
+  #     }
+  #
+  #     # This fiber would be started with resume
+  #     # It can yield or transfer, and can be transferred
+  #     # back or resumed
+  #     manager = Fiber.new {
+  #       puts "Manager: starts"
+  #       puts "Manager: transferring 'something' to worker"
+  #       result = worker.transfer('something')
+  #       puts "Manager: worker returned #{result.inspect}"
+  #       # worker.resume    # this would raise FiberError: attempt to resume a transferring fiber
+  #       Fiber.yield        # this is OK, the fiber transferred from and to, now it can yield
+  #       puts "Manager: finished"
+  #     }
+  #
+  #     puts "Starting the manager"
+  #     manager.resume
+  #     puts "Resuming the manager"
+  #     # manager.transfer  # this would raise FiberError: attempt to transfer to a yielding fiber
+  #     manager.resume
+  #
+  # *produces*
+  #
+  #     Starting the manager
+  #     Manager: starts
+  #     Manager: transferring 'something' to worker
+  #     Worker: starts
+  #     Worker: Performed "something", transferring back
+  #     Manager: worker returned "Something"
+  #     Resuming the manager
+  #     Manager: finished
+  #
+  def transfer: (*untyped) -> untyped
 end

data/core/float.rbs

@@ -1078,6 +1078,8 @@ Float::EPSILON: Float
 #
 Float::INFINITY: Float
 
+Float::Infinity: Float
+
 # <!-- rdoc-file=numeric.c -->
 # The number of base digits for the `double` data type.
 #

data/core/io.rbs

@@ -2383,6 +2383,100 @@ class IO < Object
   #
   def self.popen: (*untyped args) -> untyped
 
+  # <!--
+  #   rdoc-file=io.c
+  #   - IO.foreach(name, sep=$/ [, getline_args, open_args]) {|line| block }     -> nil
+  #   - IO.foreach(name, limit [, getline_args, open_args]) {|line| block }      -> nil
+  #   - IO.foreach(name, sep, limit [, getline_args, open_args]) {|line| block } -> nil
+  #   - IO.foreach(...)                                            -> an_enumerator
+  #   - File.foreach(name, sep=$/ [, getline_args, open_args]) {|line| block }     -> nil
+  #   - File.foreach(name, limit [, getline_args, open_args]) {|line| block }      -> nil
+  #   - File.foreach(name, sep, limit [, getline_args, open_args]) {|line| block } -> nil
+  #   - File.foreach(...)                                            -> an_enumerator
+  # -->
+  # Executes the block for every line in the named I/O port, where lines are
+  # separated by *sep*.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # If `name` starts with a pipe character (`"|"`) and the receiver is the IO
+  # class, a subprocess is created in the same way as Kernel#open, and its output
+  # is returned. Consider to use File.foreach to disable the behavior of
+  # subprocess invocation.
+  #
+  #     File.foreach("testfile") {|x| print "GOT ", x }
+  #     IO.foreach("| cat testfile") {|x| print "GOT ", x }
+  #
+  # *produces:*
+  #
+  #     GOT This is line one
+  #     GOT This is line two
+  #     GOT This is line three
+  #     GOT And so on...
+  #
+  # If the last argument is a hash, it's the keyword argument to open. See
+  # IO.readlines for details about getline_args. And see also IO.read for details
+  # about open_args.
+  #
+  def self.foreach: (string | _ToPath path, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) { (String line) -> void } -> nil
+                  | (string | _ToPath path, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> ::Enumerator[String, nil]
+
+  # <!--
+  #   rdoc-file=io.c
+  #   - IO.pipe                             ->  [read_io, write_io]
+  #   - IO.pipe(ext_enc)                    ->  [read_io, write_io]
+  #   - IO.pipe("ext_enc:int_enc" [, opt])  ->  [read_io, write_io]
+  #   - IO.pipe(ext_enc, int_enc [, opt])   ->  [read_io, write_io]
+  #   - IO.pipe(...) {|read_io, write_io| ... }
+  # -->
+  # Creates a pair of pipe endpoints (connected to each other) and returns them as
+  # a two-element array of IO objects: `[` *read_io*, *write_io* `]`.
+  #
+  # If a block is given, the block is called and returns the value of the block.
+  # *read_io* and *write_io* are sent to the block as arguments. If read_io and
+  # write_io are not closed when the block exits, they are closed. i.e. closing
+  # read_io and/or write_io doesn't cause an error.
+  #
+  # Not available on all platforms.
+  #
+  # If an encoding (encoding name or encoding object) is specified as an optional
+  # argument, read string from pipe is tagged with the encoding specified. If the
+  # argument is a colon separated two encoding names "A:B", the read string is
+  # converted from encoding A (external encoding) to encoding B (internal
+  # encoding), then tagged with B. If two optional arguments are specified, those
+  # must be encoding objects or encoding names, and the first one is the external
+  # encoding, and the second one is the internal encoding. If the external
+  # encoding and the internal encoding is specified, optional hash argument
+  # specify the conversion option.
+  #
+  # In the example below, the two processes close the ends of the pipe that they
+  # are not using. This is not just a cosmetic nicety. The read end of a pipe will
+  # not generate an end of file condition if there are any writers with the pipe
+  # still open. In the case of the parent process, the `rd.read` will never return
+  # if it does not first issue a `wr.close`.
+  #
+  #     rd, wr = IO.pipe
+  #
+  #     if fork
+  #       wr.close
+  #       puts "Parent got: <#{rd.read}>"
+  #       rd.close
+  #       Process.wait
+  #     else
+  #       rd.close
+  #       puts "Sending message to parent"
+  #       wr.write "Hi Dad"
+  #       wr.close
+  #     end
+  #
+  # *produces:*
+  #
+  #     Sending message to parent
+  #     Parent got: <Hi Dad>
+  #
+  def self.pipe: (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> [IO, IO]
+               | [X] (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) { (IO read_io, IO write_io) -> X } -> X
+
   # <!--
   #   rdoc-file=io.c
   #   - IO.read(name, [length [, offset]] [, opt])   -> string
@@ -2469,7 +2563,7 @@ class IO < Object
   #
   # See also IO.read for details about `name` and open_args.
   #
-  def self.readlines: (String name, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> ::Array[String]
+  def self.readlines: (String | _ToPath name, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode, ?chomp: boolish) -> ::Array[String]
 
   # <!--
   #   rdoc-file=io.c

data/core/kernel.rbs

@@ -2135,7 +2135,7 @@ module Kernel : BasicObject
   # :experimental
   # :   Used for experimental features that may change in future releases.
   #
-  def self?.warn: (*untyped msg, ?uplevel: Integer | nil) -> NilClass
+  def self?.warn: (*untyped msg, ?uplevel: Integer | nil, ?category: :deprecated | :experimental | nil) -> NilClass
 
   # <!--
   #   rdoc-file=process.c