rbs 0.15.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5348f41dbf169228104d4ba79ad88098ec3e8e83656b48b0b1c5877fab2e8cb7
-  data.tar.gz: c79ce48144a85642f974b0973e22f8ed97a072d98ce98e2b62aebf639c8d04f7
+  metadata.gz: 8305afa064e98cd22b78a49fb402692abed204c735a7ce05d90f6a48d7bd6b96
+  data.tar.gz: 7840d67b2bbd54eb041342e093892b6d1046b21b6655b80eba109df6b773451d
 SHA512:
-  metadata.gz: efb99d0e6476b83dbd1994a71526adab4b5b6aab2fc231a1685407739bb9a3e2f1268fb3effcbe701fa033608a0b872fd3f0011d046c599457bf47a3c3fcdb97
-  data.tar.gz: 87d13112f6abce7b7ead4e95302978d17c7c08eaf94485bf27c00c5d91e08f8c10458344661b73d518caff095787323d3694512d76796f2d20da8c2bad2e101f
+  metadata.gz: 4919d1fd1323fa5cb2c40f89f5338d2168d3ae4fcabed2e2c428b3e5b4bacda2e395e9dfb2fc52a6517e75137358118b4142b330f607f77c162f259485ac0b13
+  data.tar.gz: dc36b905d8c746eb5e976f6f3fc4a06ba8ed2b037d15d73e8bfa4360497c9c814f44dd604981f7c3622002ef0bb603b1b9374e2f49ab0af67bc35ecbe2d7b26e

data/.github/workflows/ruby.yml

@@ -13,16 +13,20 @@ jobs:
       matrix:
         container_tag:
         - master-nightly-bionic
-        - 2.6.5-bionic
-        - 2.7.0-bionic
+        - 2.6-bionic
+        - 2.7-bionic
         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:
     - uses: actions/checkout@v1
+    - name: Install dependencies
+      run: |
+        apt-get update
+        apt-get install -y libdb-dev
     - name: Install
       run: |
         ruby -v
@@ -31,4 +35,4 @@ jobs:
     - name: Run test
       run: |
         bundle exec rake ${{ matrix.job }}
-      if: "!(matrix.job == 'stdlib_test' && contains(matrix.container_tag, '2.6.5'))"
+      if: "!(matrix.job == 'stdlib_test' && contains(matrix.container_tag, '2.6'))"

data/CHANGELOG.md

@@ -2,7 +2,35 @@
 
 ## master
 
-## 0.15.0 (2020-11-2)
+## 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))
+
+## 0.18.1 (2020-12-01)
+
+* Fix `EnvironmentWalker#each_type_name` ([#494](https://github.com/ruby/rbs/pull/494))
+
+## 0.18.0 (2020-12-01)
+
+* Signature updates for `YAML`, `ObjectSpace`, and `Singleton` ([#408](https://github.com/ruby/rbs/pull/408), [#477](https://github.com/ruby/rbs/pull/477), [#482](https://github.com/ruby/rbs/pull/482))
+* `prototype rb` improvements ([#492](https://github.com/ruby/rbs/pull/492), [#487](https://github.com/ruby/rbs/pull/487), [#486](https://github.com/ruby/rbs/pull/486), [#481](https://github.com/ruby/rbs/pull/481))
+* Runtime type checker improvements ([#488](https://github.com/ruby/rbs/pull/488), [#489](https://github.com/ruby/rbs/pull/489), [#490](https://github.com/ruby/rbs/pull/490))
+* Update `DependencyWalker` API to receive _Node_ objects instead of `TypeName` ([#484](https://github.com/ruby/rbs/pull/484))
+* Assume encoding of RBS files to be UTF-8 ([#493](https://github.com/ruby/rbs/pull/493))
+
+## 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))
+* RBS repository ([#405](https://github.com/ruby/rbs/pull/405))
+* Support `alias` in `rbs prototype rb` ([#457](https://github.com/ruby/rbs/pull/457))
+
+## 0.15.0 (2020-11-02)
 
 * Signature updates for `Kernel`, `PStore`, `Enumerable`, and `Array` ([#450](https://github.com/ruby/rbs/pull/450), [#443](https://github.com/ruby/rbs/pull/443), [#438](https://github.com/ruby/rbs/pull/438), [#437](https://github.com/ruby/rbs/pull/437), [#433](https://github.com/ruby/rbs/pull/433), [#432](https://github.com/ruby/rbs/pull/432))
 * Add helper interfaces ([#434](https://github.com/ruby/rbs/pull/434), [#428](https://github.com/ruby/rbs/pull/428))

data/Gemfile

@@ -15,6 +15,7 @@ gem "json"
 gem "json-schema"
 gem 'stackprof'
 gem "goodcheck"
+gem "dbm"
 
 # Test gems
 gem "rbs-amber", path: "test/assets/test-gem"

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,19 @@ task :validate => :parser do
 
   FileList["stdlib/*"].each do |path|
     next if path =~ %r{stdlib/builtin}
-    sh "#{ruby} #{rbs} -r#{File.basename(path)} validate --silent"
+
+    lib = [File.basename(path).to_s]
+
+    if lib == ["bigdecimal-math"]
+      lib << "bigdecimal"
+    end
+
+    if lib == ["yaml"]
+      lib << "dbm"
+      lib << "pstore"
+    end
+
+    sh "#{ruby} #{rbs} #{lib.map {|l| "-r #{l}"}.join(" ")} validate --silent"
   end
 end
 
@@ -53,6 +65,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/Steepfile

@@ -3,7 +3,6 @@ target :lib do
   check "lib"
   ignore "lib/rbs/parser.rb"
 
-  vendor stdlib: "stdlib"
   library "set", "pathname", "json", "logger"
 end
 

data/bin/test_runner.rb

@@ -2,6 +2,8 @@
 
 $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')
@@ -11,6 +13,18 @@ unless IS_RUBY_27
   STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 2.7 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
 end
 
+KNOWN_FAILS = %w(dbm).map do |lib|
+  /cannot load such file -- #{lib}/
+end
+
 ARGV.each do |arg|
-  load arg
+  begin
+    load arg
+  rescue LoadError => exn
+    if KNOWN_FAILS.any? {|pat| pat =~ exn.message }
+      STDERR.puts "Loading #{arg} failed, ignoring it: #{exn.inspect}"
+    else
+      raise
+    end
+  end
 end

data/{stdlib/builtin → 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/{stdlib/builtin → 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/{stdlib/builtin → 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/{stdlib/builtin → 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/{stdlib/builtin → 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