rbs 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c8f0c698e503246f1952a9f05aed05cd1a820d4ea67721970497664bf0ee3fd
-  data.tar.gz: bf2d2e438893b213ad750d1fcd71c9d1b318f9cff1f2212ee65a3dc50cf43e39
+  metadata.gz: e7a862e1af5773b464ebf201344cf823512ca551df1f827825328863225a26c8
+  data.tar.gz: 2853162048f342a1dad949b518887e82bc4ede46d79d57626fabb49e2edf920d
 SHA512:
-  metadata.gz: 53fd4afc4d095999f7a03d6199af9cdd1009a378ebd2976c690c54a2bd2aed81d129912c70a16914733bd252a58e50223f9090bd995ca53a01a1acef513efd4a
-  data.tar.gz: b976e7a9c8bd2b80912290d7047403cfc2d7b09ed405e82aa52b75e9ed19737c144bc9c62d72f0ddcf2839117400d3e5207952753fb73097b21fdfd1192d214f
+  metadata.gz: 99fbc15297542d7d0bd952806556b128e071a7f31e0f175b573f77c00db3ec4a6ddd473f33aaf170f2a08f99991939cbcc0484d4287413c9e2b55dfbadc7dff0
+  data.tar.gz: 3553c8cc89269a9579ccd52d3c9f61bd44f4f6117856da23726930c5c5b17f5aa5da7f1d69a9748fffc1b2fe62587149856a2c1ddee0fed79fb155be6aee6037

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,43 @@
 
 ## master
 
+## 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

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
 
@@ -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/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/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

data/lib/rbs/char_scanner.rb

@@ -0,0 +1,20 @@
+module RBS
+  class CharScanner < StringScanner
+    def initialize(string)
+      super(string)
+      @charpos = 0
+    end
+
+    alias original_charpos charpos
+
+    def charpos
+      @charpos
+    end
+
+    def scan(pattern)
+      s = super
+      @charpos += s.size if s
+      s
+    end
+  end
+end

data/lib/rbs/definition_builder.rb

@@ -10,11 +10,11 @@ module RBS
     attr_reader :singleton0_cache
     attr_reader :interface_cache
 
-    def initialize(env:)
+    def initialize(env:, ancestor_builder: nil, method_builder: nil)
       @env = env
       @type_name_resolver = TypeNameResolver.from_env(env)
-      @ancestor_builder = AncestorBuilder.new(env: env)
-      @method_builder = MethodBuilder.new(env: env)
+      @ancestor_builder = ancestor_builder || AncestorBuilder.new(env: env)
+      @method_builder = method_builder || MethodBuilder.new(env: env)
 
       @instance_cache = {}
       @singleton_cache = {}
@@ -80,6 +80,7 @@ module RBS
                      when AST::Members::Alias
                        unless definition.methods.key?(original.old_name)
                          raise UnknownMethodAliasError.new(
+                           type_name: type_name,
                            original_name: original.old_name,
                            aliased_name: original.new_name,
                            location: original.location
@@ -360,15 +361,10 @@ module RBS
         when Environment::ClassEntry, Environment::ModuleEntry
           ancestors = ancestor_builder.singleton_ancestors(type_name)
           self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-          instance_type = Types::ClassInstance.new(
-            name: type_name,
-            args: entry.type_params.each.map { Types::Bases::Any.new(location: nil) },
-            location: nil
-          )
 
           Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
             def0 = build_singleton0(type_name)
-            subst = Substitution.build([], [], instance_type: instance_type)
+            subst = Substitution.new
 
             merge_definition(src: def0, dest: definition, subst: subst, keep_super: true)
 
@@ -561,6 +557,7 @@ module RBS
 
           unless original_method
             raise UnknownMethodAliasError.new(
+              type_name: definition.type_name,
               original_name: original.old_name,
               aliased_name: original.new_name,
               location: original.location
@@ -730,11 +727,13 @@ module RBS
     end
 
     def merge_method(type_name, methods, name, method, sub, implemented_in: :keep, keep_super: false)
-      defs = method.defs.yield_self do |defs|
+      if sub.empty? && implemented_in == :keep && keep_super
+        methods[name] = method
+      else
         if sub.empty? && implemented_in == :keep
-          defs
+          defs = method.defs
         else
-          defs.map do |defn|
+          defs = method.defs.map do |defn|
             defn.update(
               type: sub.empty? ? defn.type : defn.type.sub(sub),
               implemented_in: case implemented_in
@@ -748,16 +747,16 @@ module RBS
             )
           end
         end
-      end
 
-      super_method = methods[name]
+        super_method = methods[name]
 
-      methods[name] = Definition::Method.new(
-        super_method: keep_super ? method.super_method : super_method,
-        accessibility: method.accessibility,
-        defs: defs,
-        alias_of: method.alias_of
-      )
+        methods[name] = Definition::Method.new(
+          super_method: keep_super ? method.super_method : super_method,
+          accessibility: method.accessibility,
+          defs: defs,
+          alias_of: method.alias_of
+        )
+      end
     end
 
     def try_cache(type_name, cache:, key: type_name)
@@ -788,5 +787,24 @@ module RBS
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
       entry.decl.type
     end
+
+    def update(env:, except:, ancestor_builder:)
+      method_builder = self.method_builder.update(env: env, except: except)
+
+      DefinitionBuilder.new(env: env, ancestor_builder: ancestor_builder, method_builder: method_builder).tap do |builder|
+        builder.instance_cache.merge!(instance_cache)
+        builder.singleton_cache.merge!(singleton_cache)
+        builder.singleton0_cache.merge!(singleton0_cache)
+        builder.interface_cache.merge!(interface_cache)
+
+        except.each do |name|
+          builder.instance_cache.delete([name, true])
+          builder.instance_cache.delete([name, false])
+          builder.singleton_cache.delete(name)
+          builder.singleton0_cache.delete(name)
+          builder.interface_cache.delete(name)
+        end
+      end
+    end
   end
 end

data/lib/rbs/definition_builder/method_builder.rb

@@ -219,6 +219,20 @@ module RBS
           end
         end
       end
+
+      def update(env:, except:)
+        MethodBuilder.new(env: env).tap do |copy|
+          copy.instance_methods.merge!(instance_methods)
+          copy.singleton_methods.merge!(singleton_methods)
+          copy.interface_methods.merge!(interface_methods)
+
+          except.each do |type_name|
+            copy.instance_methods.delete(type_name)
+            copy.singleton_methods.delete(type_name)
+            copy.interface_methods.delete(type_name)
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/environment.rb

@@ -1,6 +1,5 @@
 module RBS
   class Environment
-    attr_reader :buffers
     attr_reader :declarations
 
     attr_reader :class_decls
@@ -169,7 +168,7 @@ module RBS
           # @type var decl: AST::Declarations::Class
           existing_entry.insert(decl: decl, outer: outer)
         else
-          raise DuplicatedDeclarationError.new(name, decl, existing_entry.primary.decl)
+          raise DuplicatedDeclarationError.new(name, decl, existing_entry.decls[0].decl)
         end
 
         prefix = outer + [decl]
@@ -204,12 +203,22 @@ module RBS
       self
     end
 
-    def resolve_type_names
+    def validate_type_params
+      class_decls.each_value do |decl|
+        decl.primary
+      end
+    end
+
+    def resolve_type_names(only: nil)
       resolver = TypeNameResolver.from_env(self)
       env = Environment.new()
 
       declarations.each do |decl|
-        env << resolve_declaration(resolver, decl, outer: [], prefix: Namespace.root)
+        if only && !only.member?(decl)
+          env << decl
+        else
+          env << resolve_declaration(resolver, decl, outer: [], prefix: Namespace.root)
+        end
       end
 
       env
@@ -431,8 +440,36 @@ module RBS
     end
 
     def inspect
-      ivars = %i[@buffers @declarations @class_decls @interface_decls @alias_decls @constant_decls @global_decls]
+      ivars = %i[@declarations @class_decls @interface_decls @alias_decls @constant_decls @global_decls]
       "\#<RBS::Environment #{ivars.map { |iv| "#{iv}=(#{instance_variable_get(iv).size} items)"}.join(' ')}>"
     end
+
+    def buffers
+      buffers_decls.keys.compact
+    end
+
+    def buffers_decls
+      # @type var hash: Hash[Buffer, Array[AST::Declarations::t]]
+      hash = {}
+
+      declarations.each do |decl|
+        location = decl.location or next
+        (hash[location.buffer] ||= []) << decl
+      end
+
+      hash
+    end
+
+    def reject
+      env = Environment.new
+
+      declarations.each do |decl|
+        unless yield(decl)
+          env << decl
+        end
+      end
+
+      env
+    end
   end
 end