rbs 0.20.1 → 1.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0358484cf9cfd6a58aba4115025628e9af481fbeb11079ba189e387486bd85
-  data.tar.gz: 01fa1f2883a0faa043d5116118e6d4bbebb33dc3290d32d9404935817e589643
+  metadata.gz: fd21602800550be064e741db770aa752eaab018ca894238f88d75d1d1e950edd
+  data.tar.gz: 346c39ff339931cf9866e29cd096a0877c620feff86044a2bbb007826276904b
 SHA512:
-  metadata.gz: 7a16ce63cf0d28ba0834f7a702767aa5dcb7440a0ef83d00f443e6877977abdb751c6e7816266d45af44cbe21b3eafc7a563edfdf678662a8412f4d8b758d80c
-  data.tar.gz: 45e237d7de22114e7f6d22f138b2850645067993c9577581842464bec7d06937a7427d13d9821d93088008f0ea838b6e475b43725d3b16b60c0e3c821b7fef93
+  metadata.gz: 94651715eeed037f3d899fdae1cc49dc5134f5d3df7da03d06b7ebc7a053d43139adf29680de4a0036446afb16ef824862fae4ad5a6870861ae48bd589799ac6
+  data.tar.gz: ec967eef1ab035d4da2fe66f8a4661523c672eb1bc13f7033ac73ac8593810fd73e52d2d52173f8284abc47273b4442f9a95f4a5325c0e265cdb6a6d6b0321e1

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## master
 
+## 1.0.0 (Pre released)
+
+* Signature updates for `URI`, `IO`, 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))
+* `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))
+  * Improve runtime type checker compatibility ([#532](https://github.com/ruby/rbs/pull/532), [#528](https://github.com/ruby/rbs/pull/528), )
+* 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))
+* 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))
+* Fix `ruby2_keywords` for `Proc` in Ruby <2.7 ([#513](https://github.com/ruby/rbs/pull/513))
+
 ## 0.20.1 (2020-12-06)
 
 * Make the order of RBS load reproducible ([#508](https://github.com/ruby/rbs/pull/508))

data/Rakefile

@@ -41,6 +41,10 @@ task :validate => :parser do
       lib << "pstore"
     end
 
+    if lib == ["logger"]
+      lib << "monitor"
+    end
+
     sh "#{ruby} #{rbs} #{lib.map {|l| "-r #{l}"}.join(" ")} validate --silent"
   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/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
 

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/goodcheck.yml

@@ -28,6 +28,26 @@ rules:
     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

data/lib/rbs.rb

@@ -23,6 +23,8 @@ require "rbs/environment_loader"
 require "rbs/builtin_names"
 require "rbs/definition"
 require "rbs/definition_builder"
+require "rbs/definition_builder/ancestor_builder"
+require "rbs/definition_builder/method_builder"
 require "rbs/variance_calculator"
 require "rbs/substitution"
 require "rbs/constant"

data/lib/rbs/ast/declarations.rb

@@ -136,10 +136,12 @@ module RBS
         class Super
           attr_reader :name
           attr_reader :args
+          attr_reader :location
 
-          def initialize(name:, args:)
+          def initialize(name:, args:, location:)
             @name = name
             @args = args
+            @location = location
           end
 
           def ==(other)
@@ -155,7 +157,8 @@ module RBS
           def to_json(*a)
             {
               name: name,
-              args: args
+              args: args,
+              location: location
             }.to_json(*a)
           end
         end
@@ -352,6 +355,8 @@ module RBS
         attr_reader :location
         attr_reader :comment
 
+        include MixinHelper
+
         def initialize(name:, type_params:, members:, annotations:, location:, comment:)
           @name = name
           @type_params = type_params

data/lib/rbs/ast/members.rb

@@ -20,7 +20,7 @@ module RBS
           @annotations = annotations
           @location = location
           @comment = comment
-          @overload = overload
+          @overload = overload ? true : false
         end
 
         def ==(other)

data/lib/rbs/cli.rb

@@ -25,7 +25,7 @@ module RBS
         end
 
         loader = EnvironmentLoader.new(core_root: core_root, repository: repository)
-        
+
         dirs.each do |dir|
           loader.add(path: Pathname(dir))
         end
@@ -43,21 +43,21 @@ module RBS
         opts.on("-r LIBRARY", "Load RBS files of the library") do |lib|
           libs << lib
         end
-  
+
         opts.on("-I DIR", "Load RBS files from the directory") do |dir|
           dirs << dir
         end
-  
+
         opts.on("--no-stdlib", "Skip loading standard library signatures") do
           self.core_root = nil
         end
-  
+
         opts.on("--repo DIR", "Add RBS repository") do |dir|
           repos << dir
         end
-  
+
         opts
-      end  
+      end
     end
 
     attr_reader :stdout
@@ -242,7 +242,7 @@ EOU
 
       env = Environment.from_loader(loader).resolve_type_names
 
-      builder = DefinitionBuilder.new(env: env)
+      builder = DefinitionBuilder::AncestorBuilder.new(env: env)
       type_name = TypeName(args[0]).absolute!
 
       if env.class_decls.key?(type_name)
@@ -626,7 +626,7 @@ EOU
 
       opts = OptionParser.new
       opts.banner = <<EOU
-Usage: rbs prototype #{format} [options...] [files...]
+Usage: rbs prototype #{format} [files...]
 #{availability}
 Generate RBS prototype from source code.
 It parses specified Ruby code and and generates RBS prototypes.
@@ -735,7 +735,7 @@ Examples:
       syntax_error = false
       args.each do |path|
         path = Pathname(path)
-        loader.each_file(path, skip_hidden: false, immediate: true) do |file_path| 
+        loader.each_file(path, skip_hidden: false, immediate: true) do |file_path|
           Parser.parse_signature(file_path.read)
         rescue RBS::Parser::SyntaxError => ex
           loc = ex.error_value.location
@@ -757,7 +757,7 @@ Examples:
       opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
       opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
       opts.push(*options.libs.map {|lib| "-r#{Shellwords.escape(lib)}"})
-      
+
       opts.empty? ? nil : opts.join(" ")
     end
 

data/lib/rbs/definition.rb

@@ -34,6 +34,20 @@ module RBS
           @implemented_in = implemented_in
         end
 
+        def ==(other)
+          other.is_a?(TypeDef) &&
+            other.type == type &&
+            other.member == member &&
+            other.defined_in == defined_in &&
+            other.implemented_in == implemented_in
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ type.hash ^ member.hash ^ defined_in.hash ^ implemented_in.hash
+        end
+
         def comment
           member.comment
         end
@@ -70,6 +84,21 @@ module RBS
         @alias_of = alias_of
       end
 
+      def ==(other)
+        other.is_a?(Method) &&
+          other.super_method == super_method &&
+          other.defs == defs &&
+          other.accessibility == accessibility &&
+          other.annotations == annotations &&
+          other.alias_of == alias_of
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ super_method.hash ^ defs.hash ^ accessibility.hash ^ annotations.hash ^ alias_of.hash
+      end
+
       def defined_in
         @defined_in ||= begin
           last_def = defs.last or raise
@@ -137,8 +166,43 @@ module RBS
     end
 
     module Ancestor
-      Instance = _ = Struct.new(:name, :args, keyword_init: true)
-      Singleton = _ = Struct.new(:name, keyword_init: true)
+      class Instance
+        attr_reader :name, :args, :source
+
+        def initialize(name:, args:, source:)
+          @name = name
+          @args = args
+          @source = source
+        end
+
+        def ==(other)
+          other.is_a?(Instance) && other.name == name && other.args == args
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ name.hash ^ args.hash
+        end
+      end
+
+      class Singleton
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Singleton) && other.name == name
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ name.hash
+        end
+      end
     end
 
     class InstanceAncestors
@@ -170,7 +234,8 @@ module RBS
             else
               Ancestor::Instance.new(
                 name: ancestor.name,
-                args: ancestor.args.map {|type| type.sub(subst) }
+                args: ancestor.args.map {|type| type.sub(subst) },
+                source: ancestor.source
               )
             end
           when Ancestor::Singleton
@@ -233,6 +298,8 @@ module RBS
       case en = entry
       when Environment::SingleEntry
         en.decl.is_a?(AST::Declarations::Interface)
+      else
+        false
       end
     end