rbs 0.19.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8305afa064e98cd22b78a49fb402692abed204c735a7ce05d90f6a48d7bd6b96
-  data.tar.gz: 7840d67b2bbd54eb041342e093892b6d1046b21b6655b80eba109df6b773451d
+  metadata.gz: be247bc7ef91a934ace7a51d77b2c9070a0b8928427221e60bc848cb3158ebaf
+  data.tar.gz: becf4b84e220f43ead96eb742cbf8cbbfec0e0fc5dce3c6837c2a5ff3a95467a
 SHA512:
-  metadata.gz: 4919d1fd1323fa5cb2c40f89f5338d2168d3ae4fcabed2e2c428b3e5b4bacda2e395e9dfb2fc52a6517e75137358118b4142b330f607f77c162f259485ac0b13
-  data.tar.gz: dc36b905d8c746eb5e976f6f3fc4a06ba8ed2b037d15d73e8bfa4360497c9c814f44dd604981f7c3622002ef0bb603b1b9374e2f49ab0af67bc35ecbe2d7b26e
+  metadata.gz: 2c200273bbcf2e454082377a0e5e1c9b4fba0f9328c44e026b0eba2a7c3175d98b2cd11b5c8267792e54e207581aea9a46cd30472a3aec640ae7aff89e9e8ebe
+  data.tar.gz: 67038167fef41256ed56262aa4b1df3a6099c82687498c7921cd869a79c927c86abd19134bd228c78abda04aed9af3b4b3ccbac38548d74c6cfba650965380d0

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## master
 
+## 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))
+* Add _singleton attribute_ syntax ([#502](https://github.com/ruby/rbs/pull/502), [#506](https://github.com/ruby/rbs/pull/506), [#505](https://github.com/ruby/rbs/pull/505))
+* Proc types with blocks ([#503](https://github.com/ruby/rbs/pull/503))
+* Add support for escape sequences in string literal types ([#501](https://github.com/ruby/rbs/pull/501))
+* Fix runtime type checking of blocks with keyword args ([#500](https://github.com/ruby/rbs/pull/500))
+
 ## 0.19.0 (2020-12-02)
 
 * Signature updates for `Monitor` and File ([#485](https://github.com/ruby/rbs/pull/485), [#495](https://github.com/ruby/rbs/pull/495))

data/Rakefile

@@ -41,6 +41,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

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/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/file.rbs

@@ -531,6 +531,9 @@ 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
+
   # Returns `true` if the named file exists and the effective used id of the
   # calling process is the owner of the file.
   #

data/core/hash.rbs

@@ -563,8 +563,6 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   alias include? has_key?
 
-  def index: (V) -> K?
-
   # Return the contents of this hash as a string.
   #
   #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
@@ -615,7 +613,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.key(300)   #=> "c"
   #     h.key(999)   #=> nil
   #
-  alias key index
+  def key: (V) -> K?
 
   # Returns `true` if the given key is present in *hsh*.
   #

data/core/io.rbs

@@ -405,7 +405,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 +484,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 +619,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 +683,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]

data/core/kernel.rbs

@@ -10,7 +10,7 @@
 # ```ruby
 # sprintf "%.1f", 1.234 #=> "1.2"
 # ```
-module Kernel
+module Kernel : BasicObject
   private
 
   def caller: (?Integer start_or_range, ?Integer length) -> ::Array[String]?

data/core/module.rbs

@@ -443,6 +443,47 @@ class Module < Object
   #
   def const_set: (Symbol | String arg0, untyped arg1) -> untyped
 
+  # Returns the Ruby source filename and line number containing first definition
+  # of constant specified. If the named constant is not found, `nil` is returned.
+  # If the constant is found, but its source location can not be extracted
+  # (constant is defined in C code), empty array is returned.
+  #
+  # *inherit* specifies whether to lookup in `mod.ancestors` (`true` by default).
+  #
+  #     # test.rb:
+  #     class A
+  #       C1 = 1
+  #     end
+  #
+  #     module M
+  #       C2 = 2
+  #     end
+  #
+  #     class B < A
+  #       include M
+  #       C3 = 3
+  #     end
+  #
+  #     class A # continuation of A definition
+  #     end
+  #
+  #     p B.const_source_location('C3')           # => ["test.rb", 11]
+  #     p B.const_source_location('C2')           # => ["test.rb", 6]
+  #     p B.const_source_location('C1')           # => ["test.rb", 2]
+  #
+  #     p B.const_source_location('C2', false)    # => nil  -- don't lookup in ancestors
+  #
+  #     p Object.const_source_location('B')       # => ["test.rb", 9]
+  #     p Object.const_source_location('A')       # => ["test.rb", 1]  -- note it is first entry, not "continuation"
+  #
+  #     p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
+  #     p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules
+  #
+  #     p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
+  #     p Object.const_source_location('String')  # => []  -- constant is defined in C code
+  #
+  def const_source_location: (Symbol | String name, ?boolish inherit) -> ([String, Integer] | [ ] | nil)
+
   # Returns an array of the names of the constants accessible in *mod*. This
   # includes the names of constants in any included modules (example at start of
   # section), unless the *inherit* parameter is set to `false`.

data/core/time.rbs

@@ -757,18 +757,6 @@ class Time < Object
   #
   def subsec: () -> Numeric
 
-  # Returns a new Time object, one second later than *time*. Time#succ is obsolete
-  # since 1.9.2 for time is not a discrete value.
-  #
-  #     t = Time.now       #=> 2007-11-19 08:23:57 -0600
-  #     t.succ             #=> 2007-11-19 08:23:58 -0600
-  #
-  # Use instead `time + 1`
-  #
-  #     t + 1              #=> 2007-11-19 08:23:58 -0600
-  #
-  def succ: () -> Time
-
   # Returns `true` if *time* represents Sunday.
   #
   #     t = Time.local(1990, 4, 1)       #=> 1990-04-01 00:00:00 -0600

data/docs/syntax.md

@@ -531,23 +531,6 @@ interface _Foo
 end
 ```
 
-### Extension declaration
-
-Extension is to model _open class_.
-
-```
-extension Kernel (Pathname)
-  def Pathname: (String) -> Pathname
-end
-
-extension Array[A] (ActiveSupport)
-  def to: (Integer) -> Array[A]
-  def from: (Integer) -> Array[A]
-  def second: () -> A?
-  def third: () -> A?
-end
-```
-
 ### Type alias declaration
 
 You can declare an alias of types.

data/goodcheck.yml

@@ -3,7 +3,7 @@ rules:
     pattern: 💪👽🚨
     message: Do you forget to delete `arglists` section?
     glob:
-      - "stdlib/**/*.rbs"
+      - "{core,stdlib}/**/*.rbs"
     fail:
       - |
         # arglists 💪👽🚨 << Delete this section
@@ -22,12 +22,32 @@ rules:
     justification:
       - Documents (comments) may contain that pattern.
     glob:
-      - "stdlib/**/*.rbs"
+      - "{core,stdlib}/**/*.rbs"
     fail:
       - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
     pass:
       - "def `send`: (String | Symbol, *untyped) -> untyped"
 
+  - id: rbs.prefer_boolish
+    pattern:
+      - regexp: '\([^(]*\bbool\b[^\n]*\)'
+      - token: "-> bool }"
+    message: |
+      Prefer `boolish` over `bool` for method arguments and block return values
+
+      See the doc below:
+      https://github.com/ruby/rbs/blob/78d04a2db0f1c4925d2b13c2939868edf9465d6c/docs/syntax.md#bool-or-boolish
+    glob:
+      - "**/*.rbs"
+    justification:
+      - When you strictly want `true | false`.
+    pass:
+      - "(arg: boolish)"
+      - "{ () -> boolish }"
+    fail:
+      - "(arg: bool)"
+      - "{ () -> bool }"
+
   - id: deprecate_stdlib_test
     pattern:
       token: < StdlibTest