rbs 2.8.4 → 3.8.1

data/lib/rbs/validator.rb

@@ -6,15 +6,17 @@ module RBS
     attr_reader :resolver
     attr_reader :definition_builder
 
-    def initialize(env:, resolver:)
+    def initialize(env:, resolver: nil)
       @env = env
       @resolver = resolver
       @definition_builder = DefinitionBuilder.new(env: env)
     end
 
-    def absolute_type(type, context:)
+    def absolute_type(type, context:, &block)
+      return type unless resolver
+
       type.map_type_name do |type_name, _, type|
-        resolver.resolve(type_name, context: context) || yield(type)
+        resolver.resolve(type_name, context: context) || (block ? yield(type) : type_name)
       end
     end
 
@@ -22,32 +24,34 @@ module RBS
     def validate_type(type, context:)
       case type
       when Types::ClassInstance, Types::Interface, Types::Alias
-        # @type var type: Types::ClassInstance | Types::Interface | Types::Alias
-        if type.name.namespace.relative?
-          type = _ = absolute_type(type, context: context) do |_|
-            NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
-          end
-        end
+        type = absolute_type(type, context: context) #: Types::ClassInstance | Types::Interface | Types::Alias
 
         definition_builder.validate_type_name(type.name, type.location)
 
-        type_params = case type
-                      when Types::ClassInstance
-                        env.class_decls[type.name].type_params
-                      when Types::Interface
-                        env.interface_decls[type.name].decl.type_params
-                      when Types::Alias
-                        env.alias_decls[type.name].decl.type_params
-                      end
-
-        InvalidTypeApplicationError.check!(
-          type_name: type.name,
-          args: type.args,
-          params: type_params.each.map(&:name),
-          location: type.location
-        )
+        normalized_type_name = env.normalize_type_name?(type.name)
+
+        if normalized_type_name
+          type_params =
+            case type
+            when Types::ClassInstance
+              entry = env.class_decls[normalized_type_name] or raise
+              entry.type_params
+            when Types::Interface
+              env.interface_decls[normalized_type_name].decl.type_params
+            when Types::Alias
+              env.type_alias_decls[normalized_type_name].decl.type_params
+            end
+
+          InvalidTypeApplicationError.check!(
+            type_name: type.name,
+            args: type.args,
+            params: type_params,
+            location: type.location
+          )
+        end
 
       when Types::ClassSingleton
+        type = absolute_type(type, context: context) #: Types::ClassSingleton
         definition_builder.validate_type_presence(type)
       end
 
@@ -98,7 +102,8 @@ module RBS
     end
 
     def validate_method_definition(method_def, type_name:)
-      method_def.types.each do |method_type|
+      method_def.overloads.each do |overload|
+        method_type = overload.method_type
         unless method_type.type_params.empty?
           loc = method_type.location&.aref(:type_params)
 
@@ -113,16 +118,16 @@ module RBS
     end
 
     def validate_type_params(params, type_name: , method_name: nil, location:)
-      # @type var each_node: TSort::_EachNode[Symbol]
-      each_node = __skip__ = -> (&block) do
+      # @type var each_node: ^() { (Symbol) -> void } -> void
+      each_node = -> (&block) do
         params.each do |param|
           block[param.name]
         end
       end
-      # @type var each_child: TSort::_EachChild[Symbol]
-      each_child = __skip__ = -> (name, &block) do
+      # @type var each_child: ^(Symbol) { (Symbol) -> void } -> void
+      each_child = -> (name, &block) do
         if param = params.find {|p| p.name == name }
-          if b = param.upper_bound
+          if b = param.upper_bound_type
             b.free_variables.each do |tv|
               block[tv]
             end
@@ -146,6 +151,26 @@ module RBS
       end
     end
 
+    def validate_class_alias(entry:)
+      case env.normalize_module_name?(entry.decl.new_name)
+      when nil
+        raise NoTypeFoundError.new(type_name: entry.decl.old_name, location: entry.decl.location&.[](:old_name))
+      when false
+        raise CyclicClassAliasDefinitionError.new(entry)
+      end
+
+      case entry
+      when Environment::ClassAliasEntry
+        unless env.class_entry(entry.decl.old_name)
+          raise InconsistentClassModuleAliasError.new(entry)
+        end
+      when Environment::ModuleAliasEntry
+        unless env.module_entry(entry.decl.old_name)
+          raise InconsistentClassModuleAliasError.new(entry)
+        end
+      end
+    end
+
     def type_alias_dependency
       @type_alias_dependency ||= TypeAliasDependency.new(env: env)
     end

data/lib/rbs/variance_calculator.rb

@@ -108,8 +108,11 @@ module RBS
     end
 
     def in_type_alias(name:)
-      decl = env.alias_decls[name].decl or raise
+      env.normalized_type_name!(name)
+
+      decl = env.type_alias_decls[name].decl or raise
       variables = decl.type_params.each.map(&:name)
+
       Result.new(variables: variables).tap do |result|
         type(decl.type, result: result, context: :covariant)
       end
@@ -129,30 +132,30 @@ module RBS
           end
         end
       when Types::ClassInstance, Types::Interface, Types::Alias
-        NoTypeFoundError.check!(type.name,
-                                env: env,
-                                location: type.location)
-
-        type_params = case type
-                      when Types::ClassInstance
-                        env.class_decls[type.name].type_params
-                      when Types::Interface
-                        env.interface_decls[type.name].decl.type_params
-                      when Types::Alias
-                        env.alias_decls[type.name].decl.type_params
-                      end
-
-        type.args.each.with_index do |ty, i|
-          if var = type_params[i]
-            case var.variance
-            when :invariant
-              type(ty, result: result, context: :invariant)
-            when :covariant
-              type(ty, result: result, context: context)
-            when :contravariant
-              type(ty, result: result, context: negate(context))
+        if type_name = env.normalize_type_name?(type.name)
+          type_params = case type
+                        when Types::ClassInstance
+                          env.class_decls[type_name].type_params
+                        when Types::Interface
+                          env.interface_decls[type_name].decl.type_params
+                        when Types::Alias
+                          env.type_alias_decls[type_name].decl.type_params
+                        end
+
+          type.args.each.with_index do |ty, i|
+            if var = type_params[i]
+              case var.variance
+              when :invariant
+                type(ty, result: result, context: :invariant)
+              when :covariant
+                type(ty, result: result, context: context)
+              when :contravariant
+                type(ty, result: result, context: negate(context))
+              end
             end
           end
+        else
+          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
         end
       when Types::Proc
         function(type.type, result: result, context: context)

data/lib/rbs/vendorer.rb

@@ -31,7 +31,7 @@ module RBS
 
       if core_root = loader.core_root
         RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
-        loader.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
+        FileFinder.each_file(core_root, skip_hidden: true) do |file_path|
           paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
         end
       end
@@ -43,7 +43,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          loader.each_file(path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path, skip_hidden: true) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path)]
           end
 
@@ -52,7 +52,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          loader.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path.path, skip_hidden: true) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
           end
         else

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "2.8.4"
+  VERSION = "3.8.1"
 end

data/lib/rbs/writer.rb

@@ -39,21 +39,27 @@ module RBS
       end
     end
 
+    def format_annotation(annotation)
+      string = annotation.string
+      case
+      when string !~ /\}/
+        "%a{#{string}}"
+      when string !~ /\)/
+        "%a(#{string})"
+      when string !~ /\]/
+        "%a[#{string}]"
+      when string !~ /\>/
+        "%a<#{string}>"
+      when string !~ /\|/
+        "%a|#{string}|"
+      else
+        raise
+      end
+    end
+
     def write_annotation(annotations)
       annotations.each do |annotation|
-        string = annotation.string
-        case
-        when string !~ /\}/
-          puts "%a{#{string}}"
-        when string !~ /\)/
-          puts "%a(#{string})"
-        when string !~ /\]/
-          puts "%a[#{string}]"
-        when string !~ /\>/
-          puts "%a<#{string}>"
-        when string !~ /\|/
-          puts "%a|#{string}|"
-        end
+        puts format_annotation(annotation)
       end
     end
 
@@ -70,7 +76,16 @@ module RBS
       end
     end
 
-    def write(decls)
+    def write(contents)
+      dirs = contents.select {|c| c.is_a?(AST::Directives::Base) } #: Array[AST::Directives::t]
+      decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
+
+      dirs.each do |dir|
+        write_directive(dir)
+      end
+
+      puts unless dirs.empty?
+
       [nil, *decls].each_cons(2) do |prev, decl|
         raise unless decl
 
@@ -79,6 +94,23 @@ module RBS
       end
     end
 
+    def write_directive(dir)
+      clauses = dir.clauses.map do |clause|
+        case clause
+        when AST::Directives::Use::SingleClause
+          if clause.new_name
+            "#{clause.type_name} as #{clause.new_name}"
+          else
+            "#{clause.type_name}"
+          end
+        when AST::Directives::Use::WildcardClause
+          "#{clause.namespace}*"
+        end
+      end
+
+      puts "use #{clauses.join(", ")}"
+    end
+
     def write_decl(decl)
       case decl
       when AST::Declarations::Class
@@ -128,13 +160,25 @@ module RBS
         write_comment decl.comment
         puts "#{decl.name}: #{decl.type}"
 
-      when AST::Declarations::Alias
+      when AST::Declarations::TypeAlias
         write_comment decl.comment
         write_annotation decl.annotations
         write_loc_source(decl) {
           puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
         }
 
+      when AST::Declarations::ClassAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "class #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::ModuleAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "module #{decl.new_name} = #{decl.old_name}"
+        }
+
       when AST::Declarations::Interface
         write_comment decl.comment
         write_annotation decl.annotations
@@ -220,8 +264,8 @@ module RBS
       when AST::Members::Alias
         write_comment member.comment
         write_annotation member.annotations
-        new_name = member.singleton? ? "self.#{member.new_name}" : member.new_name
-        old_name = member.singleton? ? "self.#{member.old_name}" : member.old_name
+        new_name = member.singleton? ? "self.#{method_name(member.new_name)}" : method_name(member.new_name)
+        old_name = member.singleton? ? "self.#{method_name(member.old_name)}" : method_name(member.old_name)
         puts "alias #{new_name} #{old_name}"
       when AST::Members::InstanceVariable
         write_comment member.comment
@@ -289,17 +333,20 @@ module RBS
 
       string << prefix
 
-      member.types.each.with_index do |type, index|
+      member.overloads.each.with_index do |overload, index|
         if index > 0
           string << padding
           string << "|"
         end
 
-        string << " #{type}\n"
+        overload.annotations.each do |annotation|
+          string << " #{format_annotation(annotation)}"
+        end
+        string << " #{overload.method_type}\n"
       end
 
-      if member.overload
-        if member.types.size > 0
+      if member.overloading?
+        if member.overloads.size > 0
           string << padding
           string << "|"
         end
@@ -338,7 +385,7 @@ module RBS
                    ""
                  end
 
-      "#{visibility}attr_#{kind} #{receiver}#{attr.name}#{var}: #{attr.type}"
+      "#{visibility}attr_#{kind} #{receiver}#{method_name(attr.name)}#{var}: #{attr.type}"
     end
 
     def preserve_empty_line(prev, decl)

data/lib/rbs.rb

@@ -16,35 +16,40 @@ require "rbs/namespace"
 require "rbs/type_name"
 require "rbs/types"
 require "rbs/method_type"
+require "rbs/file_finder"
 require "rbs/ast/type_param"
+require "rbs/ast/directives"
 require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"
+require "rbs/ast/visitor"
 require "rbs/environment"
+require "rbs/environment/use_map"
 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/diff"
 require "rbs/variance_calculator"
 require "rbs/substitution"
 require "rbs/constant"
 require "rbs/resolver/constant_resolver"
 require "rbs/resolver/type_name_resolver"
-require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"
 require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
-require "rbs/type_name_resolver"
+require "rbs/prototype/node_usage"
 require "rbs/environment_walker"
 require "rbs/vendorer"
 require "rbs/validator"
 require "rbs/factory"
 require "rbs/repository"
+require "rbs/subtractor"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"

data/lib/rdoc/discover.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  gem 'rdoc', '~> 6.4.0'
+  gem 'rdoc', '~> 6.4'
   require 'rdoc_plugin/parser'
   module RDoc
     class Parser

data/lib/rdoc_plugin/parser.rb

@@ -14,8 +14,8 @@ module RBS
       end
 
       def scan
-        ast = ::RBS::Parser.parse_signature(@content)
-        ast.each do |decl|
+        _, _, decls = ::RBS::Parser.parse_signature(@content)
+        decls.each do |decl|
           parse_member(decl: decl, context: @top_level)
         end
         @top_level
@@ -74,7 +74,7 @@ module RBS
         method = RDoc::AnyMethod.new(nil, decl.name.to_s)
         method.singleton = decl.singleton?
         method.visibility = decl.visibility
-        method.call_seq = decl.types.map { |type| "#{decl.name.to_s}#{type.to_s}" }.join("\n")
+        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
         if loc = decl.location
           method.start_collecting_tokens
           method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
@@ -108,7 +108,7 @@ module RBS
 
       def parse_include_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace
@@ -124,7 +124,7 @@ module RBS
 
       def parse_extend_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace

data/rbs.gemspec

@@ -28,12 +28,22 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin|steep)/}) }
+    `git ls-files -z`.split("\x0").reject do |f|
+      [
+        %r{^(test|spec|features|bin|steep|benchmark)/},
+        /Gemfile/
+      ].any? {|r| f.match(r) }
+    end
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 
+  if false
+    spec.required_ruby_version = ">= 3.3"
+  end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.6"
+  spec.required_ruby_version = ">= 3.1"
+  spec.add_dependency "logger"
 end

data/schema/decls.json

@@ -60,7 +60,7 @@
       "required": ["declaration", "name", "type", "comment", "location"]
     },
     "global": {
-      "title": "Global declaration: `$DEBUG: bool`, ...",
+      "title": "Global declaration: `$DEBUG: boolish`, ...",
       "type": "object",
       "properties": {
         "declaration": {

data/schema/members.json

@@ -14,10 +14,21 @@
         "kind": {
           "enum": ["instance", "singleton", "singleton_instance"]
         },
-        "types": {
+        "overloads": {
           "type": "array",
           "items": {
-            "$ref": "methodType.json"
+            "type": "object",
+            "properties": {
+              "annotations": {
+                "type": "array",
+                "items": {
+                  "$ref": "annotation.json"
+                }
+              },
+              "method_type": {
+                "$ref": "methodType.json"
+              }
+            }
           }
         },
         "comment": {
@@ -29,23 +40,17 @@
             "$ref": "annotation.json"
           }
         },
-        "attributes": {
-          "type": "array",
-          "items": {
-            "enum": ["incompatible"]
-          }
-        },
         "location": {
           "$ref": "location.json"
         },
-        "overload": {
+        "overloading": {
           "type": "boolean"
         },
         "visibility": {
           "enum": ["public", "private", null]
         }
       },
-      "required": ["member", "name", "kind", "types", "comment", "annotations", "location", "visibility"]
+      "required": ["member", "name", "kind", "overloads", "comment", "annotations", "location", "visibility", "overloading"]
     },
     "variable": {
       "title": "Declaration for instance variables and class variables",

data/sig/ancestor_builder.rbs

@@ -154,6 +154,10 @@ module RBS
                         prepended_modules: Array[Definition::Ancestor::Instance]?,
                          extended_modules: Array[Definition::Ancestor::Instance]?,
                       extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      # Fill `#source` of instance ancestor if `ancestor.name == name` and its `source` is `nil`
+      #
+      def fill_ancestor_source: (Definition::Ancestor::t, name: TypeName, source: Definition::Ancestor::Instance::source)  -> Definition::Ancestor::t
     end
   end
 end

data/sig/ancestor_graph.rbs

@@ -1,4 +1,22 @@
 module RBS
+  # AncestorGraph is a utility class that helps iterating through ancestors and descendants of a class/module
+  #
+  # ```ruby
+  # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
+  #
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  #
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # ```
+  #
+  # Note that the class works for class/module declarations.
+  # All of the *alias* classes/modules are ignored.
+  #
+  # * Alias classes/modules doesn't count as a parent nor child
+  # * Passing alias classes/modules to the method doesn't yield anything
+  #
   class AncestorGraph
     class InstanceNode
       attr_reader type_name: TypeName
@@ -19,8 +37,6 @@ module RBS
 
     def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
 
-    def build: () -> void
-
     def each_parent: (node) { (node) -> void } -> void
                    | (node) -> Enumerator[node, void]
 
@@ -33,6 +49,10 @@ module RBS
     def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
                        | (node) -> Enumerator[node, void]
 
+    private
+
+    def build: () -> void
+
     def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
 
     def register: (parent: node, child: node) -> void

data/sig/annotate/formatter.rbs

@@ -17,8 +17,8 @@ module RBS
 
       def self.translate: (RDoc::Markup::Document) -> String?
 
-      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
-                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
+      def self.each_part: (RDoc::Markup::Document | RDoc::Comment | String) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document | RDoc::Comment | String) -> Enumerator[RDoc::Markup::Document, void]
     end
   end
 end

data/sig/annotate/rdoc_annotater.rbs

@@ -17,7 +17,7 @@ module RBS
       end
 
       interface _WithRDocComment
-        def comment: () -> RDoc::Markup::Document
+        def comment: () -> (RDoc::Markup::Document | RDoc::Comment | String)
       end
 
       def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void

data/sig/cli/colored_io.rbs

@@ -0,0 +1,15 @@
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader stdout: CLI::_IO
+      def initialize: (stdout: CLI::_IO) -> void
+      def puts_green: (String) -> void
+      def puts_red: (String) -> void
+      def puts: (?String) -> void
+
+      private def can_display_colors?: () -> bool
+      private def are_colors_supported?: () -> bool
+      private def are_colors_disabled?: () -> bool
+    end
+  end
+end