rbs 0.20.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c422fed696c791b7cd4cbaa9c78cbdf28634d6152a1bd4496f801c539d74ac6
-  data.tar.gz: 46012d3a5b09cb2a529620813c71d6a730b26078d409565320a60297e4153bb4
+  metadata.gz: 8d03121b9d58454590a45862ba1d479305feae4f2b4d10707ae8e1a3c24d4aba
+  data.tar.gz: f147d99859cfc7e18b41a751587f7b2cba484bf397d5b306b9fe69f15dd4b452
 SHA512:
-  metadata.gz: 59f566eba0bb6398ee0cd4432403750ee8d3ce7e5916c61089c5c5032fff723259be3880aac88aec22d4ecaffff96c1190b18483a60feac517b3b6845bc8dae9
-  data.tar.gz: a12d3d389eead680ff98886eff428a6b2fe4e1c3cab408866be1aa34e6a5cd3737391f370655a9798c04e73062bb0170c5be2525c66c4bf3b8aa69d21dc17750
+  metadata.gz: 2e325492bc73b6d9f2f62660c4e4821f7d3853780f39a957e02ad4b30fc44ca1e687fbde9d0b2843be786e51126fbb5473e1d5ae5c9c719f255bfc50fe2f7cde
+  data.tar.gz: '03995c9d63b9db359744338497985952eed7608729cb4a259b20af6e68de5eecdf3c996404701e2821f35d4bebfdb1e2c7c8e6289f9b5a7875fd4c6c507bde27'

data/.github/workflows/ruby.yml

@@ -12,8 +12,8 @@ jobs:
     strategy:
       matrix:
         container_tag:
-        - master-nightly-bionic
-        - 2.6-bionic
+        - master-nightly-focal
+        - 3.0-focal
         - 2.7-bionic
         job:
         - test
@@ -27,12 +27,18 @@ jobs:
       run: |
         apt-get update
         apt-get install -y libdb-dev
-    - name: Install
+    - name: Install bundler
       run: |
         ruby -v
         gem install bundler
+    - name: bundle config set with
+      run: |
+        echo "NO_MINITEST=true" >> $GITHUB_ENV
+        bundle config set --local without 'minitest'
+      if: "contains(matrix.container_tag, 'master-nightly')"
+    - name: bin/setup
+      run: |
         bin/setup
     - name: Run test
       run: |
         bundle exec rake ${{ matrix.job }}
-      if: "!(matrix.job == 'stdlib_test' && contains(matrix.container_tag, '2.6'))"

data/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## master
 
+## 1.0.1 (2021-01-27)
+
+* Signature Updates
+  * PrettyPrint ([\#573](https://github.com/ruby/rbs/pull/573))
+  * FileUtils ([\#576](https://github.com/ruby/rbs/pull/576))
+  * UnboundMethod ([\#555](https://github.com/ruby/rbs/pull/555))
+  * IO ([\#571](https://github.com/ruby/rbs/pull/571))
+  * Kernel ([\#549](https://github.com/ruby/rbs/pull/549), [\#569](https://github.com/ruby/rbs/pull/569))
+  * File ([\#552](https://github.com/ruby/rbs/pull/552))
+  * Data is removed ([\#570](https://github.com/ruby/rbs/pull/570))
+  * Module ([\#568](https://github.com/ruby/rbs/pull/568))
+  * Object ([\#557](https://github.com/ruby/rbs/pull/557))
+* Renew test sample code ([#581](https://github.com/ruby/rbs/pull/581))
+* Add description to `generate:stdlib_test` Rake task ([\#578](https://github.com/ruby/rbs/pull/578))
+* Declare supported ruby version >= 2.6 ([\#548](https://github.com/ruby/rbs/pull/548))
+* Fix module self-type override ([\#577](https://github.com/ruby/rbs/pull/577))
+* Fix parser to support all operator symbols ([\#550](https://github.com/ruby/rbs/pull/550))
+* Migrate from Minitest to Test::Unit ([\#556](https://github.com/ruby/rbs/pull/556))
+* Fix type alias parsing ([\#565](https://github.com/ruby/rbs/pull/565))
+* Support end-less method definition in `prototype rb` ([\#561](https://github.com/ruby/rbs/pull/561))
+* Support method argument forwarding in `prototype rb` ([\#560](https://github.com/ruby/rbs/pull/560))
+
+## 1.0.0 (2020-12-24)
+
+* Signature updates for `URI`, `IO`, `File`, `Pathname`, `Module`, and `Time` ([#529](https://github.com/ruby/rbs/pull/529), [#521](https://github.com/ruby/rbs/pull/521), [#520](https://github.com/ruby/rbs/pull/520), [#511](https://github.com/ruby/rbs/pull/511), [#517](https://github.com/ruby/rbs/pull/517), [#542](https://github.com/ruby/rbs/pull/542), [#546](https://github.com/ruby/rbs/pull/546), [#540](https://github.com/ruby/rbs/pull/540), [#538](https://github.com/ruby/rbs/pull/538))
+* `rbs prototype runtime` generates `extend`s ([#535](https://github.com/ruby/rbs/pull/535))
+* `rbs prototype runtime` stability improvements ([#533](https://github.com/ruby/rbs/pull/533), [#526](https://github.com/ruby/rbs/pull/526))
+* `rbs prototype rb` compatibility improvements ([#545](https://github.com/ruby/rbs/pull/545))
+* Implement method names escape in `RBS::Writer` ([#537](https://github.com/ruby/rbs/pull/537))
+* Improve runtime type checker compatibility ([#532](https://github.com/ruby/rbs/pull/532), [#528](https://github.com/ruby/rbs/pull/528), [#547](https://github.com/ruby/rbs/pull/547))
+* Fix `ruby2_keywords` for `Proc` in Ruby <2.7 ([#513](https://github.com/ruby/rbs/pull/513))
+* Better compatibility for record type attribute names ([#525](https://github.com/ruby/rbs/pull/525), [#524](https://github.com/ruby/rbs/pull/524))
+* Let module self-types be classes ([#523](https://github.com/ruby/rbs/pull/523))
+* Delete `extension` syntax ([#543](https://github.com/ruby/rbs/pull/543))
+* Method resolution improvements about `alias` and `.new` ([#522](https://github.com/ruby/rbs/pull/522), [#519](https://github.com/ruby/rbs/pull/519), [#516](https://github.com/ruby/rbs/pull/516))
+* Better message for `DuplicatedMethodDefinitionError` ([#539](https://github.com/ruby/rbs/pull/539))
+
+## 0.20.1 (2020-12-06)
+
+* Make the order of RBS load reproducible ([#508](https://github.com/ruby/rbs/pull/508))
+
 ## 0.20.0 (2020-12-06)
 
 * Signature updates for `TSort`, `DBM`, `Time`, and `Hash` ([#496](https://github.com/ruby/rbs/pull/496), [#497](https://github.com/ruby/rbs/pull/497), [#499](https://github.com/ruby/rbs/pull/499), [#507](https://github.com/ruby/rbs/pull/507))

data/Gemfile

@@ -5,12 +5,12 @@ gemspec
 
 # Development dependencies
 gem "rake"
-gem "minitest"
+gem "test-unit"
+gem "test-unit-rr"
 gem "rspec"
 gem "racc"
 gem "rubocop"
 gem "rubocop-rubycw"
-gem "minitest-reporters"
 gem "json"
 gem "json-schema"
 gem 'stackprof'
@@ -22,4 +22,9 @@ gem "rbs-amber", path: "test/assets/test-gem"
 
 group :ide, optional: true do
   gem "ruby-debug-ide"
+  gem "debase", ">= 0.2.5.beta2"
+end
+
+group :minitest do
+  gem "minitest"
 end

data/README.md

@@ -107,7 +107,7 @@ instance = builder.build_instance(string)
 
 # Print the types of `gsub` method:
 puts instance.methods[:gsub].method_types.join("\n")
-# Ouputs =>
+# Outputs =>
 #  (::Regexp | ::string pattern, ::string replacement) -> ::String
 #  (::Regexp | ::string pattern, ::Hash[::String, ::String] hash) -> ::String
 #  (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String

data/Rakefile

@@ -28,8 +28,6 @@ task :validate => :parser do
   sh "#{ruby} #{rbs} validate --silent"
 
   FileList["stdlib/*"].each do |path|
-    next if path =~ %r{stdlib/builtin}
-
     lib = [File.basename(path).to_s]
 
     if lib == ["bigdecimal-math"]
@@ -41,6 +39,18 @@ task :validate => :parser do
       lib << "pstore"
     end
 
+    if lib == ["logger"]
+      lib << "monitor"
+    end
+
+    if lib == ["csv"]
+      lib << "forwardable"
+    end
+
+    if lib == ["prime"]
+      lib << "singleton"
+    end
+
     sh "#{ruby} #{rbs} #{lib.map {|l| "-r #{l}"}.join(" ")} validate --silent"
   end
 end
@@ -72,6 +82,7 @@ task :confirm_parser do
 end
 
 namespace :generate do
+  desc "Generate a test file for a stdlib class signatures"
   task :stdlib_test, [:class] do |_task, args|
     klass = args.fetch(:class) do
       raise "Class name is necessary. e.g. rake 'generate:stdlib_test[String]'"
@@ -103,7 +114,7 @@ namespace :generate do
           require_relative "test_helper"
 
           <%- unless class_methods.empty? -%>
-          class <%= klass %>SingletonTest < Minitest::Test
+          class <%= klass %>SingletonTest < Test::Unit::TestCase
             include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
@@ -121,7 +132,7 @@ namespace :generate do
           <%- end -%>
 
           <%- unless instance_methods.empty? -%>
-          class <%= klass %>Test < Minitest::Test
+          class <%= klass %>Test < Test::Unit::TestCase
             include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load

data/Steepfile

@@ -2,8 +2,9 @@ target :lib do
   signature "sig"
   check "lib"
   ignore "lib/rbs/parser.rb"
+  ignore "lib/rbs/prototype", "lib/rbs/test", "lib/rbs/test.rb"
 
-  library "set", "pathname", "json", "logger"
+  library "set", "pathname", "json", "logger", "monitor", "tsort"
 end
 
 # target :lib do

data/bin/annotate-with-rdoc

@@ -140,10 +140,6 @@ ARGV.map {|f| Pathname(f) }.each do |path|
       comment = comment_for_class(decl, stores: stores)
       decl.instance_variable_set(:@comment, comment)
 
-      print_members stores, decl.name.to_s, decl.members
-    when RBS::AST::Declarations::Extension
-      puts "  Importing documentation for #{decl.name} (#{decl.extension_name})"
-
       print_members stores, decl.name.to_s, decl.members
     end
   end

data/bin/test_runner.rb

@@ -4,13 +4,12 @@ $LOAD_PATH << File.join(__dir__, "../lib")
 
 require "set"
 
-IS_RUBY_27 = Gem::Version.new(RUBY_VERSION).yield_self do |ruby_version|
-  Gem::Version.new('2.7.0') <= ruby_version &&
-    ruby_version <= Gem::Version.new('2.8.0')
+IS_LATEST_RUBY = Gem::Version.new(RUBY_VERSION).yield_self do |ruby_version|
+  Gem::Version.new('3.0.0') <= ruby_version && ruby_version < Gem::Version.new('3.1.0')
 end
 
-unless IS_RUBY_27
-  STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 2.7 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
+unless IS_LATEST_RUBY
+  STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 3.0 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
 end
 
 KNOWN_FAILS = %w(dbm).map do |lib|

data/core/builtin.rbs

@@ -34,6 +34,10 @@ interface _Reader
   def read: (?int length, ?string outbuf) -> String?
 end
 
+interface _ReaderPartial
+  def readpartial: (int maxlen, ?string outbuf) -> String
+end
+
 interface _Writer
   # Writes the +data+ string. Returns the number of bytes written
   def write: (*_ToS data) -> Integer

data/core/encoding.rbs

@@ -567,7 +567,7 @@ Encoding::Windows_31J: Encoding
 
 Encoding::Windows_874: Encoding
 
-class Encoding::Converter < Data
+class Encoding::Converter < Object
 end
 
 Encoding::Converter::AFTER_OUTPUT: Integer

data/core/file.rbs

@@ -531,6 +531,10 @@ class File < IO
   #
   def self.mtime: (string | _ToPath | IO file_name) -> Time
 
+  # Alias of `File.new`.
+  def self.open: (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) -> instance
+               | [T] (string | _ToPath | int file_name, ?(string | int) mode, ?int perm) { (File) -> T } -> T
+
   # Returns `true` if the named file exists and the effective used id of the
   # calling process is the owner of the file.
   #

data/core/io.rbs

@@ -107,14 +107,85 @@ class IO < Object
 
   include Enumerable[String]
 
-  def <<: (untyped arg0) -> self
+  # String Output---Writes *obj* to *ios*. *obj* will be converted to a string
+  # using `to_s`.
+  #
+  #     $stdout << "Hello " << "world!\n"
+  #
+  # *produces:*
+  #
+  #     Hello world!
+  #
+  def <<: (_ToS obj) -> self
 
-  def advise: (Symbol arg0, ?Integer offset, ?Integer len) -> NilClass
+  # Announce an intention to access data from the current file in a specific
+  # pattern. On platforms that do not support the *posix_fadvise(2)* system call,
+  # this method is a no-op.
+  #
+  # *advice* is one of the following symbols:
+  #
+  # :normal
+  # :   No advice to give; the default assumption for an open file.
+  # :sequential
+  # :   The data will be accessed sequentially with lower offsets read before
+  #     higher ones.
+  # :random
+  # :   The data will be accessed in random order.
+  # :willneed
+  # :   The data will be accessed in the near future.
+  # :dontneed
+  # :   The data will not be accessed in the near future.
+  # :noreuse
+  # :   The data will only be accessed once.
+  #
+  #
+  # The semantics of a piece of advice are platform-dependent. See *man 2
+  # posix_fadvise* for details.
+  #
+  # "data" means the region of the current file that begins at *offset* and
+  # extends for *len* bytes. If *len* is 0, the region ends at the last byte of
+  # the file. By default, both *offset* and *len* are 0, meaning that the advice
+  # applies to the entire file.
+  #
+  # If an error occurs, one of the following exceptions will be raised:
+  #
+  # IOError
+  # :   The IO stream is closed.
+  # Errno::EBADF
+  # :   The file descriptor of the current file is invalid.
+  # Errno::EINVAL
+  # :   An invalid value for *advice* was given.
+  # Errno::ESPIPE
+  # :   The file descriptor of the current file refers to a FIFO or pipe. (Linux
+  #     raises Errno::EINVAL in this case).
+  # TypeError
+  # :   Either *advice* was not a Symbol, or one of the other arguments was not an
+  #     Integer.
+  # RangeError
+  # :   One of the arguments given was too big/small.
+  #
+  # This list is not exhaustive; other Errno
+  # :   exceptions are also possible.
+  #
+  def advise: ((:normal | :sequential | :random | :willneed | :dontneed | :noreuse) advise, ?Integer offset, ?Integer len) -> nil
 
-  def autoclose=: (boolish) -> bool
+  # Sets auto-close flag.
+  #
+  #     f = open("/dev/null")
+  #     IO.for_fd(f.fileno)
+  #     # ...
+  #     f.gets # may cause Errno::EBADF
+  #
+  #     f = open("/dev/null")
+  #     IO.for_fd(f.fileno).autoclose = false
+  #     # ...
+  #     f.gets # won't cause Errno::EBADF
+  #
+  def autoclose=: (bool) -> bool
 
   # Returns `true` if the underlying file descriptor of *ios* will be closed
-  # automatically at its finalization, otherwise `false` .
+  # automatically at its finalization, otherwise `false`.
+  #
   def autoclose?: () -> bool
 
   # Puts *ios* into binary mode. Once a stream is in binary mode, it cannot
@@ -405,7 +476,63 @@ class IO < Object
 
   def puts: (*untyped arg0) -> NilClass
 
-  def read: (?Integer length, ?String outbuf) -> String?
+  # Reads *length* bytes from the I/O stream.
+  #
+  # *length* must be a non-negative integer or `nil`.
+  #
+  # If *length* is a positive integer, `read` tries to read *length* bytes without
+  # any conversion (binary mode). It returns `nil` if an EOF is encountered before
+  # anything can be read. Fewer than *length* bytes are returned if an EOF is
+  # encountered during the read. In the case of an integer *length*, the resulting
+  # string is always in ASCII-8BIT encoding.
+  #
+  # If *length* is omitted or is `nil`, it reads until EOF and the encoding
+  # conversion is applied, if applicable. A string is returned even if EOF is
+  # encountered before any data is read.
+  #
+  # If *length* is zero, it returns an empty string (`""`).
+  #
+  # If the optional *outbuf* argument is present, it must reference a String,
+  # which will receive the data. The *outbuf* will contain only the received data
+  # after the method call even if it is not empty at the beginning.
+  #
+  # When this method is called at end of file, it returns `nil` or `""`, depending
+  # on *length*: `read`, `read(nil)`, and `read(0)` return `""`,
+  # `read(*positive_integer*)` returns `nil`.
+  #
+  #     f = File.new("testfile")
+  #     f.read(16)   #=> "This is line one"
+  #
+  #     # read whole file
+  #     open("file") do |f|
+  #       data = f.read   # This returns a string even if the file is empty.
+  #       # ...
+  #     end
+  #
+  #     # iterate over fixed length records
+  #     open("fixed-record-file") do |f|
+  #       while record = f.read(256)
+  #         # ...
+  #       end
+  #     end
+  #
+  #     # iterate over variable length records,
+  #     # each record is prefixed by its 32-bit length
+  #     open("variable-record-file") do |f|
+  #       while len = f.read(4)
+  #         len = len.unpack("N")[0]   # 32-bit length
+  #         record = f.read(len)       # This returns a string even if len is 0.
+  #       end
+  #     end
+  #
+  # Note that this method behaves like the fread() function in C. This means it
+  # retries to invoke read(2) system calls to read data with the specified length
+  # (or until EOF). This behavior is preserved even if *ios* is in non-blocking
+  # mode. (This method is non-blocking flag insensitive as other methods.) If you
+  # need the behavior like a single read(2) system call, consider #readpartial,
+  # #read_nonblock, and #sysread.
+  #
+  def read: (?Integer? length, ?String outbuf) -> String?
 
   def read_nonblock: (Integer len) -> String
                    | (Integer len, ?String buf) -> String
@@ -428,8 +555,63 @@ class IO < Object
 
   def readlines: (?String sep, ?Integer limit) -> ::Array[String]
 
-  def readpartial: (Integer maxlen) -> String
-                 | (Integer maxlen, ?String outbuf) -> String
+  # Reads at most *maxlen* bytes from the I/O stream. It blocks only if *ios* has
+  # no data immediately available. It doesn't block if some data available.
+  #
+  # If the optional *outbuf* argument is present, it must reference a String,
+  # which will receive the data. The *outbuf* will contain only the received data
+  # after the method call even if it is not empty at the beginning.
+  #
+  # It raises EOFError on end of file.
+  #
+  # readpartial is designed for streams such as pipe, socket, tty, etc. It blocks
+  # only when no data immediately available. This means that it blocks only when
+  # following all conditions hold.
+  # *   the byte buffer in the IO object is empty.
+  # *   the content of the stream is empty.
+  # *   the stream is not reached to EOF.
+  #
+  #
+  # When readpartial blocks, it waits data or EOF on the stream. If some data is
+  # reached, readpartial returns with the data. If EOF is reached, readpartial
+  # raises EOFError.
+  #
+  # When readpartial doesn't blocks, it returns or raises immediately. If the byte
+  # buffer is not empty, it returns the data in the buffer. Otherwise if the
+  # stream has some content, it returns the data in the stream. Otherwise if the
+  # stream is reached to EOF, it raises EOFError.
+  #
+  #     r, w = IO.pipe           #               buffer          pipe content
+  #     w << "abc"               #               ""              "abc".
+  #     r.readpartial(4096)      #=> "abc"       ""              ""
+  #     r.readpartial(4096)      # blocks because buffer and pipe is empty.
+  #
+  #     r, w = IO.pipe           #               buffer          pipe content
+  #     w << "abc"               #               ""              "abc"
+  #     w.close                  #               ""              "abc" EOF
+  #     r.readpartial(4096)      #=> "abc"       ""              EOF
+  #     r.readpartial(4096)      # raises EOFError
+  #
+  #     r, w = IO.pipe           #               buffer          pipe content
+  #     w << "abc\ndef\n"        #               ""              "abc\ndef\n"
+  #     r.gets                   #=> "abc\n"     "def\n"         ""
+  #     w << "ghi\n"             #               "def\n"         "ghi\n"
+  #     r.readpartial(4096)      #=> "def\n"     ""              "ghi\n"
+  #     r.readpartial(4096)      #=> "ghi\n"     ""              ""
+  #
+  # Note that readpartial behaves similar to sysread. The differences are:
+  # *   If the byte buffer is not empty, read from the byte buffer instead of
+  #     "sysread for buffered IO (IOError)".
+  # *   It doesn't cause Errno::EWOULDBLOCK and Errno::EINTR.  When readpartial
+  #     meets EWOULDBLOCK and EINTR by read system call, readpartial retry the
+  #     system call.
+  #
+  #
+  # The latter means that readpartial is nonblocking-flag insensitive. It blocks
+  # on the situation IO#sysread causes Errno::EWOULDBLOCK as if the fd is blocking
+  # mode.
+  #
+  def readpartial: (Integer maxlen, ?String outbuf) -> String
 
   def reopen: (IO other_IO_or_path) -> IO
             | (String other_IO_or_path, ?String mode_str) -> IO
@@ -508,13 +690,55 @@ class IO < Object
 
   def ungetc: (String arg0) -> NilClass
 
-  def write: (*_ToS arg0) -> Integer
+  # Writes the given strings to *ios*. The stream must be opened for writing.
+  # Arguments that are not a string will be converted to a string using `to_s`.
+  # Returns the number of bytes written in total.
+  #
+  #     count = $stdout.write("This is", " a test\n")
+  #     puts "That was #{count} bytes of data"
+  #
+  # *produces:*
+  #
+  #     This is a test
+  #     That was 15 bytes of data
+  #
+  def write: (*_ToS string) -> Integer
 
+  # Opens the file, optionally seeks to the given *offset*, then returns *length*
+  # bytes (defaulting to the rest of the file). #binread ensures the file is
+  # closed before returning.  The open mode would be `"rb:ASCII-8BIT"`.
+  #
+  #     IO.binread("testfile")           #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
+  #     IO.binread("testfile", 20)       #=> "This is line one\nThi"
+  #     IO.binread("testfile", 20, 10)   #=> "ne one\nThis is line "
+  #
   def self.binread: (String name, ?Integer length, ?Integer offset) -> String
 
-  def self.binwrite: (String name, _ToS arg0, ?Integer offset, ?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) -> Integer
+  # Same as IO.write except opening the file in binary mode and ASCII-8BIT
+  # encoding (`"wb:ASCII-8BIT"`).
+  #
+  def self.binwrite: (String name, _ToS string, ?Integer offset, ?mode: String mode) -> Integer
 
-  def self.copy_stream: (_Reader src, _Writer dst, ?Integer copy_length, ?Integer src_offset) -> Integer
+  # IO.copy_stream copies *src* to *dst*. *src* and *dst* is either a filename or
+  # an IO-like object. IO-like object for *src* should have #readpartial or #read
+  # method.  IO-like object for *dst* should have #write method. (Specialized
+  # mechanisms, such as sendfile system call, may be used on appropriate
+  # situation.)
+  #
+  # This method returns the number of bytes copied.
+  #
+  # If optional arguments are not given, the start position of the copy is the
+  # beginning of the filename or the current file offset of the IO. The end
+  # position of the copy is the end of file.
+  #
+  # If *copy_length* is given, No more than *copy_length* bytes are copied.
+  #
+  # If *src_offset* is given, it specifies the start position of the copy.
+  #
+  # When *src_offset* is specified and *src* is an IO, IO.copy_stream doesn't move
+  # the current file offset.
+  #
+  def self.copy_stream: ((String | _Reader | _ReaderPartial) src, (String | _Writer) dst, ?Integer copy_length, ?Integer src_offset) -> Integer
 
   def self.popen: (*untyped args) -> untyped
 
@@ -530,7 +754,12 @@ class IO < Object
 
   def self.write: (String name, _ToS arg0, ?Integer offset, ?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) -> Integer
 
-  def self.for_fd: (Integer fd, ?Integer mode, ?Integer opt) -> self
+  def self.for_fd: (int fd, ?(string | int) mode, **untyped opt) -> instance
+
+  alias self.open self.for_fd
+
+  def self.open: [A] (int fd, ?(string | int) mode, **untyped opt) { (instance) -> A } -> A
+               | ...
 
   def bytes: () { (Integer arg0) -> untyped } -> self
            | () -> ::Enumerator[Integer, self]