rbs 3.9.4 → 4.2.0

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

@@ -8,14 +8,30 @@ module RBS
           "mutex_m" => ">= 0.3.0",
           "abbrev" => nil,
           "base64" => nil,
+          "benchmark" => nil,
           "bigdecimal" => nil,
           "csv" => nil,
+          "kconv" => nil,
+          "logger" => nil,
           "minitest" => nil,
           "net-smtp" => nil,
           "nkf" => nil,
           "observer" => nil,
+          "cgi" => nil,
+          "pstore" => nil,
         }
 
+        NONGEM_STDLIBS = Set[
+          "cgi-escape",
+          "coverage",
+          "monitor",
+          "objspace",
+          "pathname",
+          "pty",
+          "ripper",
+          "socket",
+        ]
+
         class GemfileLockMismatchError < StandardError
           def initialize(expected:, actual:)
             @expected = expected
@@ -163,7 +179,9 @@ module RBS
               end
             end
           else
-            RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+            unless NONGEM_STDLIBS.include?(name)
+              RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+            end
           end
         end
 
@@ -171,8 +189,8 @@ module RBS
           return if lockfile.gems.key?(name)
 
           case name
-          when 'bigdecimal-math'
-            # The `bigdecimal-math` is never released as a gem.
+          when 'bigdecimal-math', 'kconv'
+            # These gems are never released as a gem.
             # Therefore, `assign_gem` should not be called.
             RBS.logger.info {
               from = from_gem || "rbs_collection.yaml"
@@ -183,6 +201,13 @@ module RBS
               lockfile.gems[name] = { name: name, version: "0", source: source }
             end
             return
+          when 'set'
+            # set is migrated to core from stdlib.
+            RBS.logger.info {
+              from = from_gem || "rbs_collection.yaml"
+              "`#{name}` is a part of the Ruby core library. The dependency to the library can be safely deleted from #{from}."
+            }
+            return
           when *ALUMNI_STDLIBS.keys
             version = ALUMNI_STDLIBS.fetch(name)
             if from_gem

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

@@ -3,6 +3,7 @@
 require 'digest/sha2'
 require 'open3'
 require 'find'
+require 'fileutils'
 
 module RBS
   module Collection
@@ -139,6 +140,12 @@ module RBS
                 # git v2.27.0 or greater
                 git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
               rescue CommandError
+                # The failed `--filter=blob:none` clone may leave behind a
+                # partial repository (e.g. when the server returned an error
+                # mid-clone), which would cause the fallback `git clone` to
+                # fail with "destination path ... already exists and is not
+                # an empty directory". Clean it up before retrying.
+                FileUtils.rm_rf(git_dir)
                 git 'clone', remote, git_dir.to_s, chdir: nil
               end
             end

data/lib/rbs/definition.rb

@@ -62,7 +62,12 @@ module RBS
         end
 
         def comment
-          member.comment
+          case member
+          when AST::Members::Base
+            member.comment
+          when AST::Ruby::Members::Base
+            member.leading_comment&.as_comment
+          end
         end
 
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -173,13 +173,19 @@ module RBS
       end
 
       def validate_super_class!(type_name, entry)
-        with_super_classes = entry.decls.select {|d| d.decl.super_class }
+        with_super_classes = entry.each_decl.select {|decl| decl.super_class }
 
         return if with_super_classes.size <= 1
 
-        super_types = with_super_classes.map do |d|
-          super_class = d.decl.super_class or raise
-          Types::ClassInstance.new(name: super_class.name, args: super_class.args, location: nil)
+        super_types = with_super_classes.map do |decl|
+          super_class = decl.super_class or raise
+          args = super_class.args
+
+          if align_params = entry.align_params(decl)
+            args = args.map {|type| type.sub(align_params) }
+          end
+
+          Types::ClassInstance.new(name: super_class.name, args: args, location: nil)
         end
 
         super_types.uniq!
@@ -200,8 +206,8 @@ module RBS
         case entry
         when Environment::ClassEntry
           validate_super_class!(type_name, entry)
-          primary = entry.primary
-          super_class = primary.decl.super_class
+          primary = entry.primary_decl
+          super_class = primary.super_class
 
           if type_name != BuiltinNames::BasicObject.name
             if super_class
@@ -214,13 +220,13 @@ module RBS
 
             super_name = env.normalize_module_name(super_name)
 
-            NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+            NoSuperclassFoundError.check!(super_name, env: env, location: primary.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
+            super_entry = env.class_entry(super_name, normalized: true) or raise
             super_args = AST::TypeParam.normalize_args(super_entry.type_params, super_args)
 
             ancestors = OneAncestors.class_instance(
@@ -248,7 +254,7 @@ module RBS
 
               module_name = module_self.name
               if module_name.class?
-                module_entry = env.normalized_module_class_entry(module_name) or raise
+                module_entry = env.module_class_entry(module_name, normalized: true) or raise
                 module_name = module_entry.name
                 self_args = AST::TypeParam.normalize_args(module_entry.type_params, module_self.args)
               end
@@ -283,8 +289,8 @@ module RBS
         case entry
         when Environment::ClassEntry
           validate_super_class!(type_name, entry)
-          primary = entry.primary
-          super_class = primary.decl.super_class
+          primary = entry.primary_decl
+          super_class = primary.super_class
 
           if type_name != BuiltinNames::BasicObject.name
             if super_class
@@ -295,7 +301,7 @@ module RBS
 
             super_name = env.normalize_module_name(super_name)
 
-            NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+            NoSuperclassFoundError.check!(super_name, env: env, location: primary.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
             end
@@ -348,79 +354,132 @@ module RBS
       end
 
       def mixin_ancestors0(decl, type_name, align_params:, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
-        decl.each_mixin do |member|
-          case member
-          when AST::Members::Include
-            module_name = member.name
-            module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
+        case decl
+        when AST::Declarations::Base
+          decl.each_mixin do |member|
+            case member
+            when AST::Members::Include
+              module_name = member.name
+              module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
 
-            case
-            when member.name.class? && included_modules
-              MixinClassError.check!(type_name: type_name, env: env, member: member)
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+              case
+              when member.name.class? && included_modules
+                MixinClassError.check!(type_name: type_name, env: env, member: member)
+                NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              module_decl = env.normalized_module_entry(module_name) or raise
-              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_decl = env.module_entry(module_name, normalized: true) or raise
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
 
-              module_name = env.normalize_module_name(module_name)
-              included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
-            when member.name.interface? && included_interfaces
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+                module_name = env.normalize_module_name(module_name)
+                included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              when member.name.interface? && included_interfaces
+                NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              interface_decl = env.interface_decls.fetch(module_name)
-              module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
+                interface_decl = env.interface_decls.fetch(module_name)
+                module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
 
-              included_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
-            end
+                included_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
 
-          when AST::Members::Prepend
-            if prepended_modules
-              MixinClassError.check!(type_name: type_name, env: env, member: member)
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+            when AST::Members::Prepend
+              if prepended_modules
+                MixinClassError.check!(type_name: type_name, env: env, member: member)
+                NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              module_decl = env.normalized_module_entry(member.name) or raise
-              module_name = module_decl.name
+                module_decl = env.module_entry(member.name, normalized: true) or raise
+                module_name = module_decl.name
 
-              module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
-              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
 
-              prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
-            end
+                prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
 
-          when AST::Members::Extend
-            module_name = member.name
-            module_args = member.args
+            when AST::Members::Extend
+              module_name = member.name
+              module_args = member.args
 
-            case
-            when member.name.class? && extended_modules
-              MixinClassError.check!(type_name: type_name, env: env, member: member)
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+              case
+              when member.name.class? && extended_modules
+                MixinClassError.check!(type_name: type_name, env: env, member: member)
+                NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              module_decl = env.normalized_module_entry(module_name) or raise
-              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_decl = env.module_entry(module_name, normalized: true) or raise
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
 
-              module_name = env.normalize_module_name(module_name)
-              extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
-            when member.name.interface? && extended_interfaces
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+                module_name = env.normalize_module_name(module_name)
+                extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              when member.name.interface? && extended_interfaces
+                NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              interface_decl = env.interface_decls.fetch(module_name)
-              module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
+                interface_decl = env.interface_decls.fetch(module_name)
+                module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
 
-              extended_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+                extended_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+            end
+          end
+        when AST::Ruby::Declarations::Base
+          decl.members.each do |member|
+            case member
+            when AST::Ruby::Members::IncludeMember
+              if included_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.module_entry(module_name, normalized: true) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+
+            when AST::Ruby::Members::ExtendMember
+              if extended_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.module_entry(module_name, normalized: true) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+
+            when AST::Ruby::Members::PrependMember
+              if prepended_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.module_entry(module_name, normalized: true) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
             end
           end
         end
       end
 
       def mixin_ancestors(entry, type_name, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
-        entry.decls.each do |d|
-          decl = d.decl
-
-          align_params = Substitution.build(
-            decl.type_params.each.map(&:name),
-            entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
-          )
+        entry.each_decl do |decl|
+          align_params = entry.align_params(decl)
 
           mixin_ancestors0(decl,
                            type_name,
@@ -445,7 +504,7 @@ module RBS
 
         RecursiveAncestorError.check!(self_ancestor,
                                       ancestors: building_ancestors,
-                                      location: entry.primary.decl.location)
+                                      location: entry.primary_decl.location)
         building_ancestors.push self_ancestor
 
         one_ancestors = one_instance_ancestors(type_name)
@@ -462,7 +521,7 @@ module RBS
 
             super_ancestors =
               instance_ancestors(super_name, building_ancestors: building_ancestors)
-                .apply(super_args, env: env, location: entry.primary.decl.super_class&.location)
+                .apply(super_args, env: env, location: entry.primary_decl.super_class&.location)
             super_ancestors.map! {|ancestor| fill_ancestor_source(ancestor, name: super_name, source: :super) }
             ancestors.unshift(*super_ancestors)
           end
@@ -481,7 +540,7 @@ module RBS
           included_modules.each do |mod|
             name = mod.name
             arg_types = mod.args
-            mod.source.is_a?(AST::Members::Include) or raise
+            (mod.source.is_a?(AST::Members::Include) || mod.source.is_a?(AST::Ruby::Members::IncludeMember)) or raise
             mod_ancestors =
               instance_ancestors(name, building_ancestors: building_ancestors)
                 .apply(arg_types, env: env, location: mod.source.location)
@@ -496,7 +555,7 @@ module RBS
           prepended_modules.each do |mod|
             name = mod.name
             arg_types = mod.args
-            mod.source.is_a?(AST::Members::Prepend) or raise
+            (mod.source.is_a?(AST::Members::Prepend) || mod.source.is_a?(AST::Ruby::Members::PrependMember)) or raise
             mod_ancestors =
               instance_ancestors(name, building_ancestors: building_ancestors)
                 .apply(arg_types, env: env, location: mod.source.location)
@@ -522,7 +581,7 @@ module RBS
 
         RecursiveAncestorError.check!(self_ancestor,
                                       ancestors: building_ancestors,
-                                      location: entry.primary.decl.location)
+                                      location: entry.primary_decl.location)
         building_ancestors.push self_ancestor
 
         one_ancestors = one_singleton_ancestors(type_name)
@@ -551,7 +610,7 @@ module RBS
         extended_modules.each do |mod|
           name = mod.name
           args = mod.args
-          mod.source.is_a?(AST::Members::Extend) or raise
+          (mod.source.is_a?(AST::Members::Extend) || mod.source.is_a?(AST::Ruby::Members::ExtendMember)) or raise
           mod_ancestors =
             instance_ancestors(name, building_ancestors: building_ancestors)
               .apply(args, env: env, location: mod.source.location)

data/lib/rbs/definition_builder/method_builder.rb

@@ -103,37 +103,56 @@ module RBS
             args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
             type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
             Methods.new(type: type).tap do |methods|
-              entry.decls.each do |d|
-                subst = Substitution.build(d.decl.type_params.each.map(&:name), args)
-                each_member_with_accessibility(d.decl.members) do |member, accessibility|
-                  case member
-                  when AST::Members::MethodDefinition
-                    case member.kind
-                    when :instance
-                      build_method(
-                        methods,
-                        type,
-                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
-                        accessibility: member.visibility || accessibility
-                      )
-                    when :singleton_instance
-                      build_method(
-                        methods,
-                        type,
-                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
-                        accessibility: :private
-                      )
+              entry.each_decl do |decl|
+                subst = entry.align_params(decl)
+                case decl
+                when AST::Declarations::Base
+                  each_rbs_member_with_accessibility(decl.members) do |member, accessibility|
+                    case member
+                    when AST::Members::MethodDefinition
+                      case member.kind
+                      when :instance
+                        build_method(
+                          methods,
+                          type,
+                          member: subst ? member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }) : member,
+                          accessibility: member.visibility || accessibility
+                        )
+                      when :singleton_instance
+                        build_method(
+                          methods,
+                          type,
+                          member: subst ? member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }) : member,
+                          accessibility: :private
+                        )
+                      end
+                    when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+                      if member.kind == :instance
+                        build_attribute(methods,
+                                        type,
+                                        member: subst ? member.update(type: member.type.sub(subst)) : member,
+                                        accessibility: member.visibility || accessibility)
+                      end
+                    when AST::Members::Alias
+                      if member.kind == :instance
+                        build_alias(methods, type, member: member)
+                      end
                     end
-                  when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
-                    if member.kind == :instance
-                      build_attribute(methods,
-                                      type,
-                                      member: member.update(type: member.type.sub(subst)),
-                                      accessibility: member.visibility || accessibility)
-                    end
-                  when AST::Members::Alias
-                    if member.kind == :instance
-                      build_alias(methods, type, member: member)
+                  end
+                when AST::Ruby::Declarations::Base
+                  decl.members.each do |member|
+                    case member
+                    when AST::Ruby::Members::DefMember
+                      if member.instance?
+                        build_method(
+                          methods,
+                          type,
+                          member: member,
+                          accessibility: :public
+                        )
+                      end
+                    when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+                      build_ruby_attribute(methods, type, member: member, accessibility: :public)
                     end
                   end
                 end
@@ -149,8 +168,8 @@ module RBS
             type = Types::ClassSingleton.new(name: type_name, location: nil)
 
             Methods.new(type: type).tap do |methods|
-              entry.decls.each do |d|
-                d.decl.members.each do |member|
+              entry.each_decl do |decl|
+                decl.members.each do |member|
                   case member
                   when AST::Members::MethodDefinition
                     if member.singleton?
@@ -164,6 +183,10 @@ module RBS
                     if member.kind == :singleton
                       build_alias(methods, type, member: member)
                     end
+                  when AST::Ruby::Members::DefMember
+                    if member.singleton?
+                      build_method(methods, type, member: member, accessibility: :public)
+                    end
                   end
                 end
               end
@@ -212,6 +235,24 @@ module RBS
         end
       end
 
+      def build_ruby_attribute(methods, type, member:, accessibility:)
+        member.names.each do |name|
+          if member.is_a?(AST::Ruby::Members::AttrReaderMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[name] ||= Methods::Definition.empty(type: type, name: name)
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+
+          if member.is_a?(AST::Ruby::Members::AttrWriterMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[:"#{name}="] ||= Methods::Definition.empty(type: type, name: :"#{name}=")
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+        end
+      end
+
       def build_method(methods, type, member:, accessibility:)
         defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
 
@@ -223,7 +264,7 @@ module RBS
         end
       end
 
-      def each_member_with_accessibility(members, accessibility: :public)
+      def each_rbs_member_with_accessibility(members, accessibility: :public)
         members.each do |member|
           case member
           when AST::Members::Public