rbs 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5062396fb965f4d6f07ceee4f6b82ef22a12c20897d82c6615d6765d5bf43b7f
-  data.tar.gz: 8b30dd2d71e12d56501bafc2ab4ca1d604befbc3ef797f02234b6d6acc95ac71
+  metadata.gz: f458be96f0cfc3e45e51bb77f4d42aafba7f1fee62e0ed8695eb6a95b85189b2
+  data.tar.gz: 9b84c8860182155f4e5979e668a953d1b8191754f01c6443d549fc14b5be1908
 SHA512:
-  metadata.gz: ec6b6090f0a93cbfbe2f4ffe5f5bbce253425f3f85a55dcabec2943f724a81c637c441820236aa1dcbff6104d1fe7d215e4cb38ac76c5f827677167e437761f5
-  data.tar.gz: 301d1c5a305dce97dfdd6d89c39a4deafcedc405535b13b1846b3d03af83a87747cc44ade7a0148b96af7d07d7a53b4eb7c8954344ae11d574f69ca81c3eb7a8
+  metadata.gz: f0c7616abdb3a3d4e08212014aebad858e113acf265641e4f657b2d48b9e20ec8ac7744a18f90459086be39953eb7ebef9d32acd3b22362e31d6e12e83251baf
+  data.tar.gz: ee12553e0611d2b8826d9687ab63fcc38bfb67435bcf537950b31ef6070c26d85fcf8d956ccc1285072e6513facdbd43521935ae9372a11cae6f100e16691084

data/.github/workflows/ruby.yml

@@ -18,7 +18,7 @@ jobs:
         job:
         - test
         - stdlib_test
-        - rubocop validate test_doc build test_generate_stdlib
+        - rubocop validate test_doc build test_generate_stdlib confirm_parser
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}
     steps:

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 0.17.0 (2020-11-14)
+
+* Signature updates for `Enumerable`, `Hash`, and `TSort` ([#462](https://github.com/ruby/rbs/pull/462), [#468](https://github.com/ruby/rbs/pull/468), [#471](https://github.com/ruby/rbs/pull/471), [#472](https://github.com/ruby/rbs/pull/472), [#473](https://github.com/ruby/rbs/pull/473), [#474](https://github.com/ruby/rbs/pull/474))
+* Parser error handling improvement ([#463](https://github.com/ruby/rbs/pull/463), [#475](https://github.com/ruby/rbs/pull/475))
+* Hash spread syntax handling improvement with `prototype rb` ([#465](https://github.com/ruby/rbs/pull/465))
+
 ## 0.16.0 (2020-11-05)
 
 * Signature update for `DBM` ([#441](https://github.com/ruby/rbs/pull/441))

data/README.md

@@ -46,7 +46,7 @@ module ChatApp
     def initialize: (name: String) -> void
 
     def each_member: () { (User | Bot) -> void } -> void  # `{` and `}` means block.
-                   | () -> Enumerable[User | Bot, void]   # Method can be overloaded.
+                   | () -> Enumerator[User | Bot, void]   # Method can be overloaded.
   end
 end
 ```

data/Rakefile

@@ -29,7 +29,7 @@ task :validate => :parser do
 
   FileList["stdlib/*"].each do |path|
     next if path =~ %r{stdlib/builtin}
-    
+
     lib = [File.basename(path).to_s]
 
     if lib == ["bigdecimal-math"]
@@ -60,6 +60,12 @@ task :test => :parser
 task :stdlib_test => :parser
 task :build => :parser
 
+task :confirm_parser do
+  puts "Testing if parser.rb is updated with respect to parser.y"
+  sh "racc -v -o lib/rbs/parser.rb lib/rbs/parser.y"
+  sh "git diff --exit-code lib/rbs/parser.rb"
+end
+
 namespace :generate do
   task :stdlib_test, [:class] do |_task, args|
     klass = args.fetch(:class) do

data/core/array.rbs

@@ -234,7 +234,7 @@
 # for pack.c
 #
 class Array[unchecked out Elem] < Object
-  include Enumerable[Elem, self]
+  include Enumerable[Elem]
 
   # Returns a new array.
   #

data/core/builtin.rbs

@@ -26,8 +26,8 @@ interface _ToPath
   def to_path: () -> String
 end
 
-interface _Each[out A, out B]
-  def each: { (A) -> void } -> B
+interface _Each[out A]
+  def each: { (A) -> void } -> void
 end
 
 interface _Reader

data/core/dir.rbs

@@ -7,7 +7,7 @@
 # itself (`.`).
 #
 class Dir
-  include Enumerable[String, Dir]
+  include Enumerable[String]
 
   # Returns a new directory object for the named directory.
   #

data/core/enumerable.rbs

@@ -5,7 +5,7 @@
 # objects in the collection must also implement a meaningful `<=>`
 # operator, as these methods rely on an ordering between members of the
 # collection.
-module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
+module Enumerable[unchecked out Elem]: _Each[Elem]
   # Passes each element of the collection to the given block. The method
   # returns `true` if the block never returns `false` or `nil` . If the
   # block is not given, Ruby adds an implicit block of `{ |obj| obj }` which
@@ -66,24 +66,24 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
            | () { (Elem) -> boolish } -> Integer
 
   def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
-           | (?Integer n) -> ::Enumerator[Elem, Return]
+           | (?Integer n) -> ::Enumerator[Elem, NilClass]
 
   def detect: (?Proc ifnone) { (Elem) -> boolish } -> Elem?
-            | (?Proc ifnone) -> ::Enumerator[Elem, Return]
+            | (?Proc ifnone) -> ::Enumerator[Elem, Elem?]
 
   def drop: (Integer n) -> ::Array[Elem]
 
   def drop_while: () { (Elem) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, Return]
+                | () -> ::Enumerator[Elem, ::Array[Elem]]
 
   def each_cons: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
-               | (Integer n) -> ::Enumerator[::Array[Elem], Return]
+               | (Integer n) -> ::Enumerator[::Array[Elem], NilClass]
 
-  def each_with_index: () { (Elem arg0, Integer arg1) -> untyped } -> ::Enumerable[Elem, Return]
-                     | () -> ::Enumerator[[ Elem, Integer ], Return]
+  def each_with_index: () { (Elem arg0, Integer arg1) -> untyped } -> void
+                     | () -> ::Enumerator[[ Elem, Integer ], void]
 
   def each_with_object: [U] (U arg0) { (Elem arg0, untyped arg1) -> untyped } -> U
-                      | [U] (U arg0) -> ::Enumerator[[ Elem, U ], Return]
+                      | [U] (U arg0) -> ::Enumerator[[ Elem, U ], U]
 
   # Returns an array containing the items in *enum* .
   #
@@ -97,14 +97,14 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   def entries: () -> ::Array[Elem]
 
   def find_all: () { (Elem) -> boolish } -> ::Array[Elem]
-              | () -> ::Enumerator[Elem, Return]
+              | () -> ::Enumerator[Elem, ::Array[Elem]]
 
   alias select find_all
   alias filter find_all
 
   def find_index: (?untyped value) -> Integer?
                 | () { (Elem) -> boolish } -> Integer?
-                | () -> ::Enumerator[Elem, Return]
+                | () -> ::Enumerator[Elem, Integer?]
 
   # Returns the first element, or the first `n` elements, of the enumerable.
   # If the enumerable is empty, the first form returns `nil`, and the
@@ -118,7 +118,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # [].first(10)              #=> []
   # ```
   def first: () -> Elem?
-           | (?Integer n) -> ::Array[Elem]?
+           | (Integer n) -> ::Array[Elem]?
 
   def grep: (untyped arg0) -> ::Array[Elem]
           | [U] (untyped arg0) { (Elem arg0) -> U } -> ::Array[U]
@@ -127,7 +127,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
             | [U] (untyped arg0) { (Elem arg0) -> U } -> ::Array[U]
 
   def group_by: [U] () { (Elem arg0) -> U } -> ::Hash[U, ::Array[Elem]]
-              | () -> ::Enumerator[Elem, Return]
+              | () -> ::Enumerator[Elem, ::Array[Elem]]
 
   def `include?`: (untyped arg0) -> bool
 
@@ -157,13 +157,13 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # ```
   def max: () -> Elem?
          | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (?Integer arg0) -> ::Array[Elem]
-         | (?Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+         | (Integer arg0) -> ::Array[Elem]
+         | (Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
 
-  def max_by: () -> ::Enumerator[Elem, Return]
+  def max_by: () -> ::Enumerator[Elem, Elem?]
             | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (?Integer arg0) -> ::Enumerator[Elem, Return]
-            | (?Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
+            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
+            | (Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
 
   # Returns the object in *enum* with the minimum value. The first form
   # assumes all objects implement `Comparable` ; the second uses the block
@@ -186,13 +186,13 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # ```
   def min: () -> Elem?
          | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (?Integer arg0) -> ::Array[Elem]
-         | (?Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+         | (Integer arg0) -> ::Array[Elem]
+         | (Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
 
-  def min_by: () -> ::Enumerator[Elem, Return]
+  def min_by: () -> ::Enumerator[Elem, Elem?]
             | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (?Integer arg0) -> ::Enumerator[Elem, Return]
-            | (?Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
+            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
+            | (Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
 
   # Returns a two element array which contains the minimum and the maximum
   # value in the enumerable. The first form assumes all objects implement
@@ -207,7 +207,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
             | () { (Elem arg0, Elem arg1) -> Integer } -> [ Elem?, Elem? ]
 
   def minmax_by: () -> [ Elem?, Elem? ]
-               | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Enumerator[Elem, Return]
+               | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> [ Elem?, Elem? ]
 
   # Passes each element of the collection to the given block. The method
   # returns `true` if the block never returns `true` for all elements. If
@@ -252,13 +252,13 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
           | () { (Elem) -> boolish } -> bool
 
   def partition: () { (Elem) -> boolish } -> [ ::Array[Elem], ::Array[Elem] ]
-               | () -> ::Enumerator[Elem, Return]
+               | () -> ::Enumerator[Elem, [ ::Array[Elem], ::Array[Elem] ]]
 
   def reject: () { (Elem) -> boolish } -> ::Array[Elem]
-            | () -> ::Enumerator[Elem, Return]
+            | () -> ::Enumerator[Elem, ::Array[Elem]]
 
-  def reverse_each: () { (Elem arg0) -> untyped } -> ::Enumerator[Elem, Return]
-                  | () -> ::Enumerator[Elem, Return]
+  def reverse_each: () { (Elem arg0) -> untyped } -> void
+                  | () -> ::Enumerator[Elem, void]
 
   # Returns an array containing the items in *enum* sorted.
   #
@@ -284,12 +284,12 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
           | () { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
 
   def sort_by: () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
-             | () -> ::Enumerator[Elem, Return]
+             | () -> ::Enumerator[Elem, ::Array[Elem]]
 
   def take: (Integer n) -> ::Array[Elem]?
 
   def take_while: () { (Elem) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, Return]
+                | () -> ::Enumerator[Elem, ::Array[Elem]]
 
   # Implemented in C++
   # Returns the result of interpreting *enum* as a list of `[key, value]`
@@ -306,9 +306,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   #   #=> {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}
   # ```
   def to_h: () -> ::Hash[untyped, untyped]
+          | [T, U] () { (Elem) -> [T, U] } -> ::Hash[T, U]
 
   def each_slice: (Integer n) { (::Array[Elem]) -> untyped } -> NilClass
-                | (Integer n) -> ::Enumerator[::Array[Elem], Return]
+                | (Integer n) -> ::Enumerator[::Array[Elem], NilClass]
 
   interface _NotFound[T]
     def call: () -> T
@@ -319,8 +320,8 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
           | [T] (_NotFound[T] ifnone) { (Elem) -> boolish } -> (Elem | T)
           | [T] (_NotFound[T] ifnone) -> ::Enumerator[Elem, Elem | T]
 
-  def flat_map: [U] () { (Elem arg0) -> U } -> U
-              | () -> ::Enumerator[Elem, Return]
+  def flat_map: [U] () { (Elem) -> (Array[U] | U) } -> Array[U]
+              | () -> ::Enumerator[Elem, Array[untyped]]
 
   def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
          | () -> ::Enumerator[Elem, ::Array[untyped]]
@@ -370,7 +371,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # # show pythagorean triples less than 100
   # p pythagorean_triples.take_while { |*, z| z < 100 }.force
   # ```
-  def lazy: () -> Enumerator::Lazy[Elem, Return]
+  def lazy: () -> Enumerator::Lazy[Elem, void]
 
   def uniq: () -> ::Array[Elem]
           | () { (Elem item) -> untyped } -> ::Array[Elem]
@@ -381,22 +382,22 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
          | [U] (?U arg0) { (Elem arg0) -> U } -> U
 
   def filter_map: [U] () { (Elem elem) -> (nil | false | U) } -> ::Array[U]
-                | () -> ::Enumerator[Elem, Return]
+                | () -> ::Enumerator[Elem, ::Array[untyped]]
 
-  def chain: (*self enumerables) -> ::Enumerator::Chain[Elem, ::Array[self]]
+  def chain: (*self enumerables) -> ::Enumerator::Chain[Elem]
 
   def tally: () -> ::Hash[Elem, Integer]
 
-  def each_entry: () -> ::Enumerator[Elem, Return]
+  def each_entry: () -> ::Enumerator[Elem, self]
                 | () { (Elem arg0) -> untyped } -> self
 
   # variadic type parameter is not supported yet
   # https://github.com/ruby/rbs/issues/21
-  def zip: [Elem2, Return2] (::Enumerable[Elem2, Return2] enum) -> ::Array[[Elem, Elem2 | nil]]
-         | [U, Elem2, Return2] (::Enumerable[Elem2, Return2]) { ([Elem, Elem2 | nil]) -> U } -> nil
+  def zip: [Elem2] (::Enumerable[Elem2] enum) -> ::Array[[Elem, Elem2 | nil]]
+         | [U, Elem2] (::Enumerable[Elem2]) { ([Elem, Elem2 | nil]) -> U } -> nil
 
-  def chunk: () -> ::Enumerator[Elem, Return]
-           | [U] () { (Elem elt) -> U } -> ::Enumerator[[U, Array[Elem]], void]
+  def chunk: [U] () { (Elem elt) -> U } -> ::Enumerator[[U, Array[Elem]], void]
+           | () -> ::Enumerator[Elem, Enumerator[untyped, untyped]]
 
   def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]
 

data/core/enumerator.rbs

@@ -96,7 +96,7 @@
 # # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
 # ```
 class Enumerator[unchecked out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
+  include Enumerable[Elem]
 
   def each: () { (Elem arg0) -> untyped } -> Return
           | () -> self
@@ -242,8 +242,8 @@ class Enumerator[unchecked out Elem, out Return] < Object
                  | [U] (U arg0) -> ::Enumerator[[ Elem, U ], Return]
 end
 
-class Enumerator::Generator[out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
+class Enumerator::Generator[out Elem] < Object
+  include Enumerable[Elem]
 end
 
 class Enumerator::Lazy[out Elem, out Return] < Enumerator[Elem, Return]
@@ -257,6 +257,6 @@ class Enumerator::Yielder < Object
   def to_proc: () -> Proc
 end
 
-class Enumerator::Chain[out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
+class Enumerator::Chain[out Elem] < Object
+  include Enumerable[Elem]
 end

data/core/hash.rbs

@@ -106,7 +106,7 @@
 # See also Object#hash and Object#eql?
 #
 class Hash[unchecked out K, unchecked out V] < Object
-  include Enumerable[[K, V], Hash[K, V]]
+  include Enumerable[[K, V]]
 
   # Creates a new hash populated with the given objects.
   #
@@ -143,7 +143,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 < h1    #=> false
   #     h1 < h1    #=> false
   #
-  def <: (::Hash[K, V]) -> bool
+  def <: [A, B] (::Hash[A, B]) -> bool
 
   # Returns `true` if *hash* is subset of *other* or equals to *other*.
   #
@@ -153,7 +153,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 <= h1   #=> false
   #     h1 <= h1   #=> true
   #
-  def <=: (::Hash[K, V]) -> bool
+  def <=: [A, B] (::Hash[A, B]) -> bool
 
   # Equality---Two hashes are equal if they each contain the same number of keys
   # and if each key-value pair is equal to (according to Object#==) the
@@ -183,7 +183,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 > h1    #=> true
   #     h1 > h1    #=> false
   #
-  def >: (::Hash[K, V]) -> bool
+  def >: [A, B] (::Hash[A, B]) -> bool
 
   # Returns `true` if *other* is subset of *hash* or equals to *hash*.
   #
@@ -193,7 +193,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 >= h1   #=> true
   #     h1 >= h1   #=> true
   #
-  def >=: (::Hash[K, V]) -> bool
+  def >=: [A, B] (::Hash[A, B]) -> bool
 
   # Element Reference---Retrieves the *value* object corresponding to the *key*
   # object. If not found, returns the default value (see Hash::new for details).
@@ -720,8 +720,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Hash#update is an alias for Hash#merge!.
   #
-  def merge!: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
-            | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> (C) } -> ::Hash[A | K, B | V | C]
+  def merge!: (*::Hash[K, V] other_hashes) -> self
+            | (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> (V) } -> self
 
   # Searches through the hash comparing *obj* with the value using `==`. Returns
   # the first key-value pair (two-element array) that matches. See also
@@ -770,7 +770,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = { "a" => 100, "b" => 200 }
   #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
   #
-  def replace: [A, B] (Hash[A, B] | _ToHash[A, B]) -> Hash[A, B]
+  def replace: (Hash[K, V]) -> self
 
   # Returns a new hash consisting of entries for which the block returns true.
   #

data/core/io.rbs

@@ -105,7 +105,7 @@
 class IO < Object
   include File::Constants
 
-  include Enumerable[String, IO]
+  include Enumerable[String]
 
   def <<: (untyped arg0) -> self
 

data/core/range.rbs

@@ -88,7 +88,7 @@
 # r.member?(Xs.new(5))       #=> true
 # ```
 class Range[out Elem] < Object
-  include Enumerable[Elem, Range[Elem]]
+  include Enumerable[Elem]
 
   def ==: (untyped obj) -> bool
 

data/core/struct.rbs

@@ -27,7 +27,7 @@
 # struct member which is either a quoted string ( `"name"` ) or a
 # [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html) ( `:name` ).
 class Struct[Elem] < Object
-  include Enumerable[Elem, Struct[Elem]]
+  include Enumerable[Elem]
 
   type attribute_name = Symbol | String
 

data/lib/rbs/definition.rb

@@ -60,12 +60,14 @@ module RBS
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :alias_of
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [])
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
         @extra_annotations = annotations
+        @alias_of = alias_of
       end
 
       def defined_in
@@ -110,7 +112,8 @@ module RBS
         self.class.new(
           super_method: super_method&.sub(s),
           defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -118,7 +121,8 @@ module RBS
         self.class.new(
           super_method: super_method&.map_type(&block),
           defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -126,7 +130,8 @@ module RBS
         self.class.new(
           super_method: super_method,
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
     end