rbs 3.6.1 → 3.9.5

data/lib/rbs/annotate/annotations.rb

@@ -93,7 +93,7 @@ module RBS
           case
           when match = source.match(/(?<constant_name>[^#]+)#(?<method_name>.+)/)
             [
-              TypeName(match[:constant_name] || raise),
+              TypeName.parse(match[:constant_name] || raise),
               [
                 false,
                 (match[:method_name] or raise).to_sym
@@ -101,7 +101,7 @@ module RBS
             ]
           when match = source.match(/(?<constant_name>[^#]+)\.(?<method_name>.+)/)
             [
-              TypeName(match[:constant_name] || raise),
+              TypeName.parse(match[:constant_name] || raise),
               [
                 true,
                 (match[:method_name] or raise).to_sym
@@ -109,7 +109,7 @@ module RBS
             ]
           else
             [
-              TypeName(source),
+              TypeName.parse(source),
               nil
             ]
           end

data/lib/rbs/annotate/rdoc_source.rb

@@ -31,7 +31,7 @@ module RBS
       end
 
       def find_class(typename)
-        classes = []
+        classes = [] #: Array[::RDoc::ClassModule]
 
         @stores.each do |store|
           if klass = store.find_class_or_module(typename.relative!.to_s)
@@ -70,7 +70,7 @@ module RBS
       def find_const(const_name)
         namespace =
           if const_name.namespace.empty?
-            TypeName("::Object")
+            TypeName.parse("::Object")
           else
             const_name.namespace.to_type_name
           end

data/lib/rbs/ast/declarations.rb

@@ -349,12 +349,14 @@ module RBS
         attr_reader :type
         attr_reader :location
         attr_reader :comment
+        attr_reader :annotations
 
-        def initialize(name:, type:, location:, comment:)
+        def initialize(name:, type:, location:, comment:, annotations: [])
           @name = name
           @type = type
           @location = location
           @comment = comment
+          @annotations = annotations || []
         end
 
         def ==(other)
@@ -385,12 +387,14 @@ module RBS
         attr_reader :type
         attr_reader :location
         attr_reader :comment
+        attr_reader :annotations
 
-        def initialize(name:, type:, location:, comment:)
+        def initialize(name:, type:, location:, comment:, annotations: [])
           @name = name
           @type = type
           @location = location
           @comment = comment
+          @annotations = annotations
         end
 
         def ==(other)
@@ -417,13 +421,14 @@ module RBS
       end
 
       class AliasDecl < Base
-        attr_reader :new_name, :old_name, :location, :comment
+        attr_reader :new_name, :old_name, :location, :comment, :annotations
 
-        def initialize(new_name:, old_name:, location:, comment:)
+        def initialize(new_name:, old_name:, location:, comment:, annotations: [])
           @new_name = new_name
           @old_name = old_name
           @location = location
           @comment = comment
+          @annotations = annotations
         end
 
         def ==(other)

data/lib/rbs/ast/directives.rb

@@ -34,6 +34,16 @@ module RBS
         end
       end
 
+      class ResolveTypeNames < Base
+        attr_reader :location
+
+        attr_reader :value
+
+        def initialize(value:, location:)
+          @value = value
+          @location = location
+        end
+      end
     end
   end
 end

data/lib/rbs/ast/members.rb

@@ -30,6 +30,8 @@ module RBS
           end
 
           def sub(subst)
+            return self if subst.empty?
+
             update(method_type: self.method_type.sub(subst))
           end
 

data/lib/rbs/ast/type_param.rb

@@ -5,13 +5,13 @@ module RBS
     class TypeParam
       attr_reader :name, :variance, :location, :upper_bound_type, :default_type
 
-      def initialize(name:, variance:, upper_bound:, location:, default_type: nil)
+      def initialize(name:, variance:, upper_bound:, location:, default_type: nil, unchecked: false)
         @name = name
         @variance = variance
         @upper_bound_type = upper_bound
         @location = location
-        @unchecked = false
         @default_type = default_type
+        @unchecked = unchecked
       end
 
       def upper_bound
@@ -56,16 +56,6 @@ module RBS
         }.to_json(state)
       end
 
-      def rename(name)
-        TypeParam.new(
-          name: name,
-          variance: variance,
-          upper_bound: upper_bound_type,
-          location: location,
-          default_type: default_type
-        ).unchecked!(unchecked?)
-      end
-
       def map_type(&block)
         if b = upper_bound_type
           _upper_bound_type = yield(b)

data/lib/rbs/cli/diff.rb

@@ -11,8 +11,8 @@ module RBS
         # @type var type_name: String?
         type_name = nil
         library_options = library_options
-        before_path = []
-        after_path = []
+        before_path = [] #: Array[String]
+        after_path = [] #: Array[String]
         detail = false
 
         opt = OptionParser.new do |o|
@@ -46,7 +46,7 @@ module RBS
         end
 
         @diff = RBS::Diff.new(
-          type_name: TypeName(type_name).absolute!,
+          type_name: TypeName.parse(type_name).absolute!,
           library_options: library_options,
           after_path: after_path,
           before_path: before_path,

data/lib/rbs/cli/validate.rb

@@ -52,7 +52,7 @@ module RBS
         loader = options.loader()
         @env = Environment.from_loader(loader).resolve_type_names
         @builder = DefinitionBuilder.new(env: @env)
-        @validator = Validator.new(env: @env, resolver: Resolver::TypeNameResolver.new(@env))
+        @validator = Validator.new(env: @env)
         exit_error = false
         limit = nil #: Integer?
         OptionParser.new do |opts|
@@ -196,6 +196,7 @@ EOU
                   end
                 InvalidTypeApplicationError.check!(type_name: member.name, params: params, args: member.args, location: member.location)
               when AST::Members::Var
+                @validator.validate_variable(member)
                 void_type_context_validator(member.type)
                 if member.is_a?(AST::Members::ClassVariable)
                   no_self_type_validator(member.type)

data/lib/rbs/cli.rb

@@ -288,7 +288,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder::AncestorBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
 
       case env.constant_entry(type_name)
       when Environment::ClassEntry, Environment::ModuleEntry, Environment::ClassAliasEntry, Environment::ModuleAliasEntry
@@ -353,7 +353,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
 
       if env.module_name?(type_name)
         definition = case kind
@@ -406,7 +406,7 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      type_name = TypeName(args[0]).absolute!
+      type_name = TypeName.parse(args[0]).absolute!
       method_name = args[1].to_sym
 
       unless env.module_name?(type_name)
@@ -479,9 +479,9 @@ EOU
       builder = DefinitionBuilder.new(env: env)
       resolver = Resolver::ConstantResolver.new(builder: builder)
 
-      resolver_context = context ? [nil, TypeName(context).absolute!] : nil #: Resolver::context
+      resolver_context = context ? [nil, TypeName.parse(context).absolute!] : nil #: Resolver::context
       stdout.puts "Context: #{context}"
-      const_name = TypeName(args[0])
+      const_name = TypeName.parse(args[0])
       stdout.puts "Constant name: #{const_name}"
 
       if const_name.absolute?
@@ -554,11 +554,11 @@ EOU
       when "rbi", "rb"
         run_prototype_file(format, args)
       when "runtime"
-        require_libs = []
-        relative_libs = []
+        require_libs = [] #: Array[String]
+        relative_libs = [] #: Array[String]
         merge = false
         todo = false
-        owners_included = []
+        owners_included = [] #: Array[Symbol]
         outline = false
         autoload = false
 
@@ -587,11 +587,11 @@ EOU
             merge = true
           end
           opts.on("--todo", "Generates only undefined methods compared to objects") do
-            Warning.warn("Geneating prototypes with `--todo` option is experimental\n", category: :experimental)
+            Warning.warn("Generating prototypes with `--todo` option is experimental\n", category: :experimental)
             todo = true
           end
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
-            owners_included << klass
+            owners_included << klass.to_sym
           end
           opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
             outline = true
@@ -615,9 +615,9 @@ EOU
             ::Module.prepend(hook)
             ::Kernel.prepend(hook)
 
-            arguments = []
+            arguments = [] #: Array[[Module, interned]]
             TracePoint.new(:call) do |tp|
-              base = tp.self.kind_of?(Module) ? tp.self : Kernel
+              base = tp.self.kind_of?(Module) ? tp.self : Kernel #: Module
               name = (tp.binding or raise).local_variable_get(:name)
               arguments << [base, name]
             end.enable(target: hook.instance_method(:autoload), &block)
@@ -979,7 +979,7 @@ Options:
     end
 
     def test_opt options
-      opts = []
+      opts = [] #: Array[String]
 
       opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
       opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
@@ -1056,7 +1056,7 @@ EOB
       require 'bundler'
 
       opts = collection_options(args)
-      params = {}
+      params = {} #: Hash[Symbol, untyped]
       opts.order args.drop(1), into: params
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)
@@ -1155,7 +1155,7 @@ EOB
             # Generate RBS files from the codebase.
             $ rbs prototype rb lib/ > generated.rbs
 
-            # Write more descrictive types by hand.
+            # Write more descriptive types by hand.
             $ $EDITOR handwritten.rbs
 
             # Remove hand-written method definitions from generated.rbs.
@@ -1163,7 +1163,7 @@ EOB
 
           Options:
         HELP
-        opts.on('-w', '--write', 'Overwrite files directry') { write_to_file = true }
+        opts.on('-w', '--write', 'Overwrite files directory') { write_to_file = true }
         opts.on('--subtrahend=PATH', '') { |path| subtrahend_paths << path }
         opts.parse!(args)
       end

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -4,6 +4,18 @@ module RBS
   module Collection
     class Config
       class LockfileGenerator
+        ALUMNI_STDLIBS = {
+          "mutex_m" => ">= 0.3.0",
+          "abbrev" => nil,
+          "base64" => nil,
+          "bigdecimal" => nil,
+          "csv" => nil,
+          "minitest" => nil,
+          "net-smtp" => nil,
+          "nkf" => nil,
+          "observer" => nil,
+        }
+
         class GemfileLockMismatchError < StandardError
           def initialize(expected:, actual:)
             @expected = expected
@@ -58,9 +70,10 @@ module RBS
 
         def generate
           config.gems.each do |gem|
-            if Sources::Stdlib.instance.has?(gem["name"], nil) || gem.dig("source", "type") == "stdlib"
+            case
+            when gem.dig("source", "type") == "stdlib"
               unless gem.fetch("ignore", false)
-                assign_stdlib(name: gem["name"], from_gem: nil)
+                assign_stdlib(name: gem["name"])
               end
             else
               assign_gem(name: gem["name"], version: gem["version"])
@@ -113,6 +126,11 @@ module RBS
                   find_source(name: name)
                 end
 
+              if source.is_a?(Sources::Stdlib)
+                assign_stdlib(name: name)
+                return
+              end
+
               if source
                 installed_version = version
                 best_version = find_best_version(version: installed_version, versions: source.versions(name))
@@ -149,16 +167,48 @@ module RBS
           end
         end
 
-        private def assign_stdlib(name:, from_gem:)
+        private def assign_stdlib(name:, from_gem: nil)
           return if lockfile.gems.key?(name)
 
           case name
-          when 'rubygems', 'set'
-            msg = "`#{name}` has been moved to core library, so it is always loaded. Remove explicit loading `#{name}`"
-            msg << " from `#{from_gem}`" if from_gem
-            RBS.logger.warn msg
-
+          when 'bigdecimal-math'
+            # The `bigdecimal-math` is never released as a gem.
+            # Therefore, `assign_gem` should not be called.
+            RBS.logger.info {
+              from = from_gem || "rbs_collection.yaml"
+              "`#{name}` is included in the RBS dependencies of `#{from}`, but the type definition as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies of `#{from}`."
+            }
+            source = find_source(name: name)
+            if source&.is_a?(Sources::Stdlib)
+              lockfile.gems[name] = { name: name, version: "0", source: source }
+            end
             return
+          when *ALUMNI_STDLIBS.keys
+            version = ALUMNI_STDLIBS.fetch(name)
+            if from_gem
+              # From `dependencies:` of a `manifest.yaml` of a gem
+              source = find_source(name: name) or raise
+              if source.is_a?(Sources::Stdlib) && version
+                RBS.logger.warn {
+                  "`#{name}` is included in the RBS dependencies of `#{from_gem}`, but the type definition as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+                }
+              else
+                RBS.logger.info {
+                  "`#{name}` is included in the RBS dependencies of `#{from_gem}`, but the type definition as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies of `#{from_gem}`."
+                }
+                assign_gem(name: name, version: nil)
+                return
+              end
+            else
+              # From `gems:` of a `rbs_collection.yaml`
+              RBS.logger.warn {
+                if version
+                  "`#{name}` as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+                else
+                  "`#{name}` as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies in your rbs_collection.yaml."
+                end
+              }
+            end
           end
 
           source = Sources::Stdlib.instance

data/lib/rbs/collection/config.rb

@@ -66,13 +66,15 @@ module RBS
       def sources
         @sources ||= [
           Sources::Rubygems.instance,
-          Sources::Stdlib.instance,
-          *@data['sources'].map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
+          *@data['sources'].map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) },
+          Sources::Stdlib.instance
         ]
       end
 
       def gems
-        @data['gems'] ||= []
+        @data['gems'] ||= (
+          [] #: Array[gem_entry]
+        )
       end
     end
   end

data/lib/rbs/collection/sources/rubygems.rb

@@ -5,7 +5,7 @@ require 'singleton'
 module RBS
   module Collection
     module Sources
-      # Signatures that are inclduded in gem package as sig/ directory.
+      # Signatures that are included in gem package as sig/ directory.
       class Rubygems
         include Base
         include Singleton

data/lib/rbs/collection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require 'fileutils'
 
 require_relative './cli/colored_io'
 require_relative './collection/sources'

data/lib/rbs/definition.rb

@@ -6,18 +6,23 @@ module RBS
       attr_reader :parent_variable
       attr_reader :type
       attr_reader :declared_in
+      attr_reader :source
 
-      def initialize(parent_variable:, type:, declared_in:)
+      def initialize(parent_variable:, type:, declared_in:, source:)
         @parent_variable = parent_variable
         @type = type
         @declared_in = declared_in
+        @source = source
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           parent_variable: parent_variable,
           type: type.sub(s),
-          declared_in: declared_in
+          declared_in: declared_in,
+          source: source
         )
       end
     end
@@ -28,12 +33,18 @@ module RBS
         attr_reader :member
         attr_reader :defined_in
         attr_reader :implemented_in
+        attr_reader :member_annotations
+        attr_reader :overload_annotations
+        attr_reader :annotations
 
-        def initialize(type:, member:, defined_in:, implemented_in:)
+        def initialize(type:, member:, defined_in:, implemented_in:, overload_annotations: [])
           @type = type
           @member = member
           @defined_in = defined_in
           @implemented_in = implemented_in
+          @member_annotations = []
+          @overload_annotations = []
+          @annotations = []
         end
 
         def ==(other)
@@ -54,12 +65,11 @@ module RBS
           member.comment
         end
 
-        def annotations
-          member.annotations
-        end
-
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
-          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in)
+          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in).tap do |type_def|
+            type_def.overload_annotations.replace(self.overload_annotations)
+            type_def.member_annotations.replace(self.member_annotations)
+          end
         end
 
         def overload?
@@ -70,20 +80,33 @@ module RBS
             false
           end
         end
+
+        def each_annotation(&block)
+          if block
+            member_annotations.each(&block)
+            overload_annotations.each(&block)
+          else
+            enum_for :each_annotation
+          end
+        end
       end
 
       attr_reader :super_method
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :annotations
       attr_reader :alias_of
+      attr_reader :alias_member
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:, alias_member: nil)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
-        @extra_annotations = annotations
+        @extra_annotations = []
+        @annotations = []
         @alias_of = alias_of
+        @alias_member = alias_member
       end
 
       def ==(other)
@@ -92,7 +115,8 @@ module RBS
           other.defs == defs &&
           other.accessibility == accessibility &&
           other.annotations == annotations &&
-          other.alias_of == alias_of
+          other.alias_of == alias_of &&
+          other.alias_member == alias_member
       end
 
       alias eql? ==
@@ -123,10 +147,6 @@ module RBS
         @comments ||= defs.map(&:comment).compact.uniq
       end
 
-      def annotations
-        @annotations ||= @extra_annotations + defs.flat_map {|d| d.annotations }
-      end
-
       def members
         @members ||= defs.map(&:member).uniq
       end
@@ -140,49 +160,44 @@ module RBS
       end
 
       def sub(s)
-        self.class.new(
+        return self if s.empty?
+
+        update(
           super_method: super_method&.sub(s),
-          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) }
         )
       end
 
       def map_type(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) }
         )
       end
 
       def map_type_bound(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type_bound(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) }
         )
       end
 
       def map_method_type(&block)
-        self.class.new(
-          super_method: super_method,
+        update(
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
         )
       end
 
-      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations)
+      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations, alias_member: self.alias_member)
         self.class.new(
           super_method: super_method,
           defs: defs,
           accessibility: accessibility,
           alias_of: alias_of,
-          annotations: annotations
-        )
+          alias_member: alias_member
+        ).tap do |method|
+          method.annotations.replace(annotations)
+        end
       end
     end
 
@@ -345,6 +360,8 @@ module RBS
     end
 
     def sub(s)
+      return self if s.empty?
+
       definition = self.class.new(type_name: type_name, self_type: _ = self_type.sub(s), ancestors: ancestors, entry: entry)
 
       definition.methods.merge!(methods.transform_values {|method| method.sub(s) })

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -209,7 +209,7 @@ module RBS
               super_args = super_class.args
             else
               super_name = BuiltinNames::Object.name
-              super_args = []
+              super_args = [] #: Array[Types::t]
             end
 
             super_name = env.normalize_module_name(super_name)
@@ -217,6 +217,7 @@ module RBS
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
+              InvalidTypeApplicationError.check2!(type_name: super_class.name, args: super_class.args, env: env, location: super_class.location)
             end
 
             super_entry = env.normalized_class_entry(super_name) or raise
@@ -243,6 +244,7 @@ module RBS
           else
             entry.self_types.each do |module_self|
               NoSelfTypeFoundError.check!(module_self, env: env)
+              InvalidTypeApplicationError.check2!(type_name: module_self.name, args: module_self.args, env: env, location: module_self.location)
 
               module_name = module_self.name
               if module_name.class?
@@ -525,7 +527,7 @@ module RBS
 
         one_ancestors = one_singleton_ancestors(type_name)
 
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         case super_class = one_ancestors.super_class
         when Definition::Ancestor::Instance
@@ -581,7 +583,7 @@ module RBS
         building_ancestors.push self_ancestor
 
         one_ancestors = one_interface_ancestors(type_name)
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         included_interfaces = one_ancestors.included_interfaces or raise
         included_interfaces.each do |a|