rbs 3.9.2 → 4.0.0.dev.1

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -173,12 +173,12 @@ 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
+        super_types = with_super_classes.map do |decl|
+          super_class = decl.super_class or raise
           Types::ClassInstance.new(name: super_class.name, args: super_class.args, location: nil)
         end
 
@@ -200,8 +200,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,7 +214,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)
               InvalidTypeApplicationError.check2!(type_name: super_class.name, args: super_class.args, env: env, location: super_class.location)
@@ -283,8 +283,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 +295,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,75 +348,78 @@ 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.normalized_module_entry(module_name) 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.normalized_module_entry(member.name) 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.normalized_module_entry(module_name) 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
+          # noop
         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
-
+        entry.each_decl do |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) }
@@ -445,7 +448,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 +465,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
@@ -522,7 +525,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)

data/lib/rbs/definition_builder/method_builder.rb

@@ -103,38 +103,53 @@ 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
+              entry.each_decl do |decl|
+                subst = Substitution.build(decl.type_params.each.map(&:name), args)
+                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: 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
+                        )
+                      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
+                    end
+                  end
+                when AST::Ruby::Declarations::Base
+                  decl.members.each do |member|
+                    case member
+                    when AST::Ruby::Members::DefMember
                       build_method(
                         methods,
                         type,
-                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
-                        accessibility: :private
+                        member: member,
+                        accessibility: :public
                       )
                     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
                   end
                 end
               end
@@ -149,8 +164,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?
@@ -223,7 +238,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

data/lib/rbs/definition_builder.rb

@@ -126,10 +126,10 @@ module RBS
       entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
       args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
 
-      entry.decls.each do |d|
-        subst_ = subst + Substitution.build(d.decl.type_params.each.map(&:name), args)
+      entry.each_decl do |decl|
+        subst_ = subst + Substitution.build(decl.type_params.each.map(&:name), args)
 
-        d.decl.members.each do |member|
+        decl.members.each do |member|
           case member
           when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
             if member.kind == :instance
@@ -174,7 +174,7 @@ module RBS
 
       try_cache(type_name, cache: instance_cache) do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.instance_ancestors(type_name)
         args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
@@ -234,7 +234,7 @@ module RBS
     def build_singleton0(type_name)
       try_cache type_name, cache: singleton0_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton0: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.singleton_ancestors(type_name)
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
@@ -272,8 +272,8 @@ module RBS
           interface_methods = interface_methods(all_interfaces)
           import_methods(definition, type_name, methods, interface_methods, Substitution.new, nil)
 
-          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::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
                 if member.kind == :singleton
@@ -306,7 +306,7 @@ module RBS
 
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.singleton_ancestors(type_name)
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
@@ -452,6 +452,10 @@ module RBS
         case decl
         when AST::Declarations::Class
           decl.super_class&.location
+        when AST::Ruby::Declarations::ClassDecl
+          nil
+        else
+          raise "Unexpected `:super` source location with #{decl.class}"
         end
       else
         source.location
@@ -471,7 +475,7 @@ module RBS
           validate_params_with(type_params, result: result) do |param|
             decl = case entry = definition.entry
                    when Environment::ModuleEntry, Environment::ClassEntry
-                     entry.primary.decl
+                     entry.primary_decl
                    when Environment::SingleEntry
                      entry.decl
                    end
@@ -762,6 +766,37 @@ module RBS
         )
 
         method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::DefMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [original, *duplicated_method.members]
+          )
+        end
+
+        defs = original.overloads.map do |overload|
+          Definition::Method::TypeDef.new(
+            type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+            member: original,
+            defined_in: defined_in,
+            implemented_in: implemented_in
+          ).tap do |type_def|
+            # Keep the original annotations given to overloads.
+            type_def.overload_annotations.replace(overload.annotations)
+          end
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: existing_method,
+          defs: defs,
+          accessibility: :public,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
+
       when nil
         # Overloading method definition only
 

data/lib/rbs/environment/class_entry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RBS
+  class Environment
+    class ClassEntry
+      attr_reader :name
+
+      attr_reader :context_decls
+
+      def initialize(name)
+        @name = name
+        @context_decls = []
+      end
+
+      def <<(context_decl)
+        context_decls << context_decl
+        @primary_decl = nil
+        self
+      end
+
+      def each_decl(&block)
+        if block
+          context_decls.each do |_, decl|
+            yield decl
+          end
+        else
+          enum_for(__method__ || raise)
+        end
+      end
+
+      def empty?
+        context_decls.empty?
+      end
+
+      def primary_decl
+        @primary_decl ||= nil.tap do
+          # @type break: declaration
+
+          decl = each_decl.find {|decl| decl.super_class }
+          break decl if decl
+
+          decl = each_decl.first
+          break decl if decl
+        end || raise("Cannot find primary declaration for #{name}")
+      end
+
+      def type_params
+        validate_type_params
+        primary_decl.type_params
+      end
+
+      def validate_type_params
+        unless context_decls.empty?
+          first_decl, *rest_decls = each_decl.to_a
+          first_decl or raise
+
+          first_params = first_decl.type_params
+          first_names = first_params.map(&:name)
+          rest_decls.each do |other_decl|
+            other_params = other_decl.type_params
+            unless first_names.size == other_params.size && first_params == AST::TypeParam.rename(other_params, new_names: first_names)
+              raise GenericParameterMismatchError.new(name: name, decl: other_decl)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/environment/module_entry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RBS
+  class Environment
+    class ModuleEntry
+      attr_reader :name
+
+      attr_reader :context_decls
+
+      def initialize(name)
+        @name = name
+        @context_decls = []
+      end
+
+      def <<(context_decl)
+        context_decls << context_decl
+        self
+      end
+
+      def each_decl(&block)
+        if block
+          context_decls.each do |_, decl|
+            yield decl
+          end
+        else
+          enum_for(__method__ || raise)
+        end
+      end
+
+      def empty?
+        context_decls.empty?
+      end
+
+      def primary_decl
+        each_decl.first or raise
+      end
+
+      def type_params
+        validate_type_params
+        primary_decl.type_params
+      end
+
+      def self_types
+        each_decl.flat_map do |decl|
+          decl.self_types
+        end.uniq
+      end
+
+      def validate_type_params
+        unless context_decls.empty?
+          first_decl, *rest_decls = each_decl.to_a
+          first_decl or raise
+
+          first_params = first_decl.type_params
+          first_names = first_params.map(&:name)
+          rest_decls.each do |other_decl|
+            other_params = other_decl.type_params
+            unless first_names.size == other_params.size && first_params == AST::TypeParam.rename(other_params, new_names: first_names)
+              raise GenericParameterMismatchError.new(name: name, decl: other_decl)
+            end
+          end
+        end
+      end
+    end
+  end
+end