rbs 1.0.3 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 036100021b0cbb49dd861874f559cf64e038d283bf6dbcb6068db71fc9900a69
-  data.tar.gz: 9bdf796be6710ae9f9a7c1ab50e7ce1871d86e34b9712fb03fa7418652499e25
+  metadata.gz: 8d83588e6a5f96ce5953f7c94eaf6f745eddadd1446e91946f18d4b81efb70bc
+  data.tar.gz: 3d7c3148afbe2a6041de6c909ddf08d7991e17c6fa2cebd4393a920582539263
 SHA512:
-  metadata.gz: c70a2e6caa836c06d8136806b45d307f46b40e5cb21a6d4b4eaf49850fa884be0b240e1c8617e3f5d2cca75be25d91cfb0573613fff5ad8c945d0f9f45f8bdb0
-  data.tar.gz: fdc96f11d612bdc16672620fd135360a0ff31cb6d32d181aa70785a0b15bf63d13588be95ade7a702d1c64091f22378c1a864a80dbcdf81c129dcdbb091f5afe
+  metadata.gz: e8a99b1a837a8cf4c7f1ce6b148c25e66433db2800d356a51ad58cc9b41280b097d3db7a3138679bc34f3c536415473a1b5423fac44f1048359d8556c938c298
+  data.tar.gz: 145caea219b5fb1d209e37f03ae0d4999f788895cf6a6dc4150d9ee4864be46ee7dc1126b95d0ddb0b1f1a4576c46f502c415aef56143900be61b726f81a291f

data/.github/workflows/ruby.yml

@@ -27,10 +27,10 @@ jobs:
       run: |
         apt-get update
         apt-get install -y libdb-dev
-    - name: Install bundler
+    - name: Update rubygems & bundler
       run: |
         ruby -v
-        gem install bundler
+        gem update --system
     - name: bundle config set with
       run: |
         echo "NO_MINITEST=true" >> $GITHUB_ENV

data/CHANGELOG.md

@@ -2,6 +2,71 @@
 
 ## master
 
+## 1.1.1 (2021-03-12)
+
+### Signature updates
+
+* rubygem ([#630](https://github.com/ruby/rbs/pull/630))
+
+## 1.1.0 (2021-03-08)
+
+### Summary
+
+Errors are now organized by `RBS::BaseError`, `RBS::ParsingError`, `RBS::LoadingError`, and `RBS::DefinitionError`.
+The library users can rescue RBS related errors with `RBS::BaseError`, parsing errors with `RBS::ParsingError`, and other errors with `RBS::LoadingError` and `RBS::DefinitionErrors`.
+
+Updating a part of environments are supported. Library users can remove declarations read from a set of files, adding new declarations, running name resolution related to the new decls, and deleting `DefinitionBuilder` caches related to the changes.
+See `RBS::Environment#reject`, `RBS::Environment#resolve_type_names`, `RBS::AncestorGraph`, and `RBS::DefinitionBuilder#update`.
+
+`RBS::DefinitionBuilder#build_singleton` now returns definitions containing `instance` type, which had returned resolved class instance types. This is a breaking change, but we consider it a bug fix because `RBS::DefinitionBuilder#build_instance` has returned `instance` types and `#build_singleton` has returned `class` type.
+
+### Signature updates
+
+* rubygem ([\#605](https://github.com/ruby/rbs/pull/605), [\#610](https://github.com/ruby/rbs/pull/610))
+* Array ([\#612](https://github.com/ruby/rbs/pull/612), [\#614](https://github.com/ruby/rbs/pull/614))
+* cgi/core ([\#599](https://github.com/ruby/rbs/pull/599))
+* Thread ([\#618](https://github.com/ruby/rbs/pull/618))
+
+### Language updates
+
+* Allow trailing comma for Record and Tuple types ([\#606](https://github.com/ruby/rbs/pull/606))
+
+### Library changes
+
+* Allow partial update of RBS declarations ([\#608](https://github.com/ruby/rbs/pull/608), [\#621](https://github.com/ruby/rbs/pull/621))
+* Let errors have `TypeName` ([\#611](https://github.com/ruby/rbs/pull/611))
+* Add `Parser::LexerError` ([\#615](https://github.com/ruby/rbs/pull/615))
+* Performance improvement ([\#617](https://github.com/ruby/rbs/pull/617), [\#620](https://github.com/ruby/rbs/pull/620))
+* No substitute `instance` types on `#build_singleton` ([\#619](https://github.com/ruby/rbs/pull/619))
+
+### Miscellaneous
+
+* Make racc name customizable by `RACC` environment variable ([\#602](https://github.com/ruby/rbs/pull/602))
+* Suppress warnings ([\#624](https://github.com/ruby/rbs/pull/624))
+* Remove needless `Gem::Version` polyfill ([\#622](https://github.com/ruby/rbs/pull/622))
+
+## 1.0.6 (2021-02-17)
+
+* Signature Updates
+  * `Enumerable` ([\#595](https://github.com/ruby/rbs/pull/595), [\#596](https://github.com/ruby/rbs/pull/596), [\#601](https://github.com/ruby/rbs/pull/601))
+  * `#as_json` ([\#597](https://github.com/ruby/rbs/pull/597))
+
+## 1.0.5 (2021-02-13)
+
+* Signature Updates
+  * Enumerable ([\#596](https://github.com/ruby/rbs/pull/596))
+  * Set ([\#595](https://github.com/ruby/rbs/pull/595))
+  * `#to_json` ([\#592](https://github.com/ruby/rbs/pull/592))
+  * `<=>` ([\#593](https://github.com/ruby/rbs/pull/593))
+  * Timeout ([\#586](https://github.com/ruby/rbs/pull/586))
+  * URI::RFC2396_Parser ([\#587](https://github.com/ruby/rbs/pull/587))
+* Rename generic class parameters on re-open ([\#594](https://github.com/ruby/rbs/pull/594))
+* Make `refute_send_type` check that method call doesn't match with types in RBS ([\#588](https://github.com/ruby/rbs/pull/588))
+
+## 1.0.4 (2021-01-31)
+
+* Unbundle `rr` to run test in `ruby/ruby` repo ([#585](https://github.com/ruby/rbs/pull/585))
+
 ## 1.0.3 (2021-01-28)
 
 * Set up `#ancestors` and `#location` of `RecursiveAncestorError` ([#583](https://github.com/ruby/rbs/pull/583))

data/Gemfile

@@ -6,7 +6,6 @@ gemspec
 # Development dependencies
 gem "rake"
 gem "test-unit"
-gem "test-unit-rr"
 gem "rspec"
 gem "racc"
 gem "rubocop"

data/Rakefile

@@ -3,6 +3,7 @@ require "rake/testtask"
 require "rbconfig"
 
 ruby = ENV["RUBY"] || RbConfig.ruby
+racc = ENV.fetch("RACC", "racc")
 rbs = File.join(__dir__, "exe/rbs")
 bin = File.join(__dir__, "bin")
 
@@ -67,7 +68,7 @@ task :rubocop do
 end
 
 rule ".rb" => ".y" do |t|
-  sh "racc -v -o #{t.name} #{t.source}"
+  sh "#{racc} -v -o #{t.name} #{t.source}"
 end
 
 task :parser => "lib/rbs/parser.rb"
@@ -77,7 +78,7 @@ 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 "#{racc} -v -o lib/rbs/parser.rb lib/rbs/parser.y"
   sh "git diff --exit-code lib/rbs/parser.rb"
 end
 

data/Steepfile

@@ -5,6 +5,8 @@ target :lib do
   ignore "lib/rbs/prototype", "lib/rbs/test", "lib/rbs/test.rb"
 
   library "set", "pathname", "json", "logger", "monitor", "tsort"
+  signature "stdlib/strscan/0/"
+  signature "stdlib/rubygems/0/"
 end
 
 # target :lib do

data/bin/rbs-prof

@@ -4,6 +4,6 @@ require "stackprof"
 
 out = ENV["RBS_STACKPROF_OUT"] || 'tmp/stackprof-cpu-rbs.dump'
 
-StackProf.run(mode: :cpu, out: out) do
+StackProf.run(mode: :cpu, out: out, raw: true) do
   load File.join(__dir__, "../exe/rbs")
 end

data/core/array.rbs

@@ -1584,8 +1584,8 @@ class Array[unchecked out Elem] < Object
   #     a.sample(random: Random.new(1))     #=> 6
   #     a.sample(4, random: Random.new(1))  #=> [6, 10, 9, 2]
   #
-  def sample: (?random: Random rng) -> Elem?
-            | (?int n, ?random: Random rng) -> ::Array[Elem]
+  def sample: (?random: _Rand rng) -> Elem?
+            | (?int n, ?random: _Rand rng) -> ::Array[Elem]
 
   # Returns a new array containing all elements of `ary` for which the given
   # `block` returns a true value.
@@ -1649,7 +1649,7 @@ class Array[unchecked out Elem] < Object
   #
   #     a.shuffle(random: Random.new(1))  #=> [1, 3, 2]
   #
-  def shuffle: (?random: Random rng) -> ::Array[Elem]
+  def shuffle: (?random: _Rand rng) -> ::Array[Elem]
 
   # Shuffles elements in `self` in place.
   #
@@ -1661,7 +1661,7 @@ class Array[unchecked out Elem] < Object
   #
   #     a.shuffle!(random: Random.new(1))  #=> [1, 3, 2]
   #
-  def shuffle!: (?random: Random rng) -> self
+  def shuffle!: (?random: _Rand rng) -> self
 
   alias size length
 
@@ -1736,7 +1736,7 @@ class Array[unchecked out Elem] < Object
   # See also Enumerable#sort_by.
   #
   def sort: () -> ::Array[Elem]
-          | () { (Elem a, Elem b) -> ::Integer? } -> ::Array[Elem]
+          | () { (Elem a, Elem b) -> ::Integer } -> ::Array[Elem]
 
   # Sorts `self` in place.
   #
@@ -1757,7 +1757,7 @@ class Array[unchecked out Elem] < Object
   # See also Enumerable#sort_by.
   #
   def sort!: () -> self
-           | () { (Elem a, Elem b) -> ::Integer? } -> self
+           | () { (Elem a, Elem b) -> ::Integer } -> self
 
   # Sorts `self` in place using a set of keys generated by mapping the values in
   # `self` through the given block.
@@ -1997,6 +1997,10 @@ interface _ToAry[T]
   def to_ary: () -> ::Array[T]
 end
 
+interface _Rand
+  def rand: (::Integer max) -> ::Integer
+end
+
 interface Array::_Pattern[T]
   def ===: (T) -> bool
 end

data/core/complex.rbs

@@ -121,7 +121,7 @@ class Complex < Numeric
   #     Complex(2)     <=> 2               #=> 0
   #     Complex(2)     <=> 3               #=> -1
   #
-  def <=>: (Numeric) -> Integer?
+  def <=>: (untyped) -> Integer?
 
   # Returns true if cmp equals object numerically.
   #

data/core/enumerable.rbs

@@ -286,8 +286,22 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   def sort_by: () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
              | () -> ::Enumerator[Elem, ::Array[Elem]]
 
-  def take: (Integer n) -> ::Array[Elem]?
+  # Returns first n elements from *enum*.
+  #
+  #     a = [1, 2, 3, 4, 5, 0]
+  #     a.take(3)             #=> [1, 2, 3]
+  #     a.take(30)            #=> [1, 2, 3, 4, 5, 0]
+  #
+  def take: (Integer n) -> ::Array[Elem]
 
+  # Passes elements to the block until the block returns `nil` or `false`, then
+  # stops iterating and returns an array of all prior elements.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     a = [1, 2, 3, 4, 5, 0]
+  #     a.take_while { |i| i < 3 }   #=> [1, 2]
+  #
   def take_while: () { (Elem) -> boolish } -> ::Array[Elem]
                 | () -> ::Enumerator[Elem, ::Array[Elem]]
 

data/core/enumerator.rbs

@@ -244,6 +244,8 @@ end
 
 class Enumerator::Generator[out Elem] < Object
   include Enumerable[Elem]
+
+  def each: () { (Elem) -> void } -> void
 end
 
 class Enumerator::Lazy[out Elem, out Return] < Enumerator[Elem, Return]
@@ -259,4 +261,6 @@ end
 
 class Enumerator::Chain[out Elem] < Object
   include Enumerable[Elem]
+
+  def each: () { (Elem) -> void } -> void
 end

data/core/file.rbs

@@ -985,7 +985,8 @@ class File::Stat < Object
   include Comparable
 
   def initialize: (String file) -> Object
-  def <=>: (File::Stat other) -> Integer?
+  def <=>: (File::Stat other) -> Integer
+         | (untyped) -> nil
 
   def atime: () -> Time
 

data/core/integer.rbs

@@ -112,7 +112,8 @@ class Integer < Numeric
   #
   # `nil` is returned if the two values are incomparable.
   #
-  def <=>: (Numeric) -> Integer?
+  def <=>: (Integer | Rational) -> Integer
+         | (untyped) -> Integer?
 
   # Returns `true` if `int` equals `other` numerically. Contrast this with
   # Integer#eql?, which requires `other` to be an Integer.

data/core/module.rbs

@@ -90,7 +90,7 @@ class Module < Object
   # Returns `nil` if `module` has no relationship with `other_module`, if
   # `other_module` is not a module, or if the two values are incomparable.
   #
-  def <=>: (Module other) -> Integer?
+  def <=>: (untyped other) -> Integer?
 
   # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
   # are the same object.  Typically, this method is overridden in descendant

data/core/rational.rbs

@@ -125,7 +125,8 @@ class Rational < Numeric
   #
   #     Rational(1, 3) <=> "0.3"           #=> nil
   #
-  def <=>: (Numeric) -> Integer?
+  def <=>: (Integer | Rational) -> Integer
+         | (untyped) -> Integer?
 
   # Returns `true` if `rat` equals `object` numerically.
   #

data/core/string.rbs

@@ -91,7 +91,8 @@ class String
   #     "abcdef" <=> "ABCDEF"    #=> 1
   #     "abcdef" <=> 1           #=> nil
   #
-  def <=>: (untyped other) -> Integer?
+  def <=>: (string other) -> Integer
+         | (untyped other) -> Integer?
 
   # Equality---Returns whether `str` == `obj`, similar to Object#==.
   #

data/core/symbol.rbs

@@ -47,7 +47,8 @@ class Symbol
   #
   # See String#<=> for more information.
   #
-  def <=>: (untyped other) -> Integer?
+  def <=>: (Symbol other) -> Integer
+         | (untyped other) -> Integer?
 
   # Equality---If *sym* and *obj* are exactly the same symbol, returns `true`.
   #

data/core/thread.rbs

@@ -287,7 +287,20 @@ class Thread < Object
 
   def group: () -> ThreadGroup?
 
-  def initialize: (*untyped args) -> Thread
+  # Creates a new thread executing the given block.
+  #
+  # Any `args` given to ::new will be passed to the block:
+  #
+  #     arr = []
+  #     a, b, c = 1, 2, 3
+  #     Thread.new(a,b,c) { |d,e,f| arr << d << e << f }.join
+  #     arr #=> [1, 2, 3]
+  #
+  # A ThreadError exception is raised if ::new is called without a block.
+  #
+  # If you're going to subclass Thread, be sure to call super in your `initialize`
+  # method, otherwise a ThreadError will be raised.
+  def initialize: (*untyped) { (*untyped) -> void } -> void
 
   # The calling thread will suspend execution and run this `thr` .
   #

data/core/time.rbs

@@ -230,7 +230,8 @@ class Time < Object
   #     t2 <=> t           #=> 1
   #     t <=> t            #=> 0
   #
-  def <=>: (Time other) -> Integer?
+  def <=>: (Time other) -> Integer
+         | (untyped other) -> Integer?
 
   def >: (Time arg0) -> bool
 

data/docs/stdlib.md

@@ -70,7 +70,7 @@ One non-trivial but absolutely better solution is to make a tool:
 The next step should be importing RDoc documents.
 
 ```
-$ bin/annotate-with-rdoc stdlib/pathname/pathname.rbs
+$ bin/annotate-with-rdoc stdlib/pathname/0/pathname.rbs
 Loading store from /Users/soutaro/.rbenv/versions/2.7.0-dev/share/ri/2.7.0/system...
 Loading store from /Users/soutaro/.rbenv/versions/2.7.0-dev/share/ri/2.7.0/site...
 Opening stdlib/pathname/pathname.rbs...

data/lib/rbs.rb

@@ -7,7 +7,9 @@ require "pp"
 require "ripper"
 require "logger"
 require "tsort"
+require "strscan"
 
+require "rbs/char_scanner"
 require "rbs/errors"
 require "rbs/buffer"
 require "rbs/location"
@@ -40,6 +42,7 @@ require "rbs/vendorer"
 require "rbs/validator"
 require "rbs/factory"
 require "rbs/repository"
+require "rbs/ancestor_graph"
 
 begin
   require "rbs/parser"

data/lib/rbs/ancestor_graph.rb

@@ -0,0 +1,90 @@
+module RBS
+  class AncestorGraph
+    InstanceNode = _ = Struct.new(:type_name, keyword_init: true)
+    SingletonNode = _ = Struct.new(:type_name, keyword_init: true)
+
+    attr_reader :env
+    attr_reader :ancestor_builder
+    attr_reader :parents
+    attr_reader :children
+
+    def initialize(env:, ancestor_builder: DefinitionBuilder::AncestorBuilder.new(env: env))
+      @env = env
+      @ancestor_builder = ancestor_builder
+      build()
+    end
+
+    def build()
+      @parents = {}
+      @children = {}
+
+      env.class_decls.each_key do |type_name|
+        build_ancestors(InstanceNode.new(type_name: type_name), ancestor_builder.one_instance_ancestors(type_name))
+        build_ancestors(SingletonNode.new(type_name: type_name), ancestor_builder.one_singleton_ancestors(type_name))
+      end
+      env.interface_decls.each_key do |type_name|
+        build_ancestors(InstanceNode.new(type_name: type_name), ancestor_builder.one_interface_ancestors(type_name))
+      end
+    end
+
+    def build_ancestors(node, ancestors)
+      ancestors.each_ancestor do |ancestor|
+        case ancestor
+        when Definition::Ancestor::Instance
+          register(child: node, parent: InstanceNode.new(type_name: ancestor.name))
+        when Definition::Ancestor::Singleton
+          register(child: node, parent: SingletonNode.new(type_name: ancestor.name))
+        end
+      end
+    end
+
+    def register(parent:, child:)
+      (parents[child] ||= Set[]) << parent
+      (children[parent] ||= Set[]) << child
+    end
+
+    def each_parent(node, &block)
+      if block
+        parents[node]&.each(&block)
+      else
+        enum_for :each_parent, node
+      end
+    end
+
+    def each_child(node, &block)
+      if block
+        children[node]&.each(&block)
+      else
+        enum_for :each_child, node
+      end
+    end
+
+    def each_ancestor(node, yielded: Set[], &block)
+      if block
+        each_parent(node) do |parent|
+          unless yielded.member?(parent)
+            yielded << parent
+            yield parent
+            each_ancestor(parent, yielded: yielded, &block)
+          end
+        end
+      else
+        enum_for :each_ancestor, node
+      end
+    end
+
+    def each_descendant(node, yielded: Set[], &block)
+      if block
+        each_child(node) do |child|
+          unless yielded.member?(child)
+            yielded << child
+            yield child
+            each_descendant(child, yielded: yielded, &block)
+          end
+        end
+      else
+        enum_for :each_descendant, node
+      end
+    end
+  end
+end