Fix AncestorBuilder

Author: soutaro

lib/rbs/definition_builder/ancestor_builder.rb

@@ -414,7 +414,60 @@ def mixin_ancestors0(decl, type_name, align_params:, included_modules:, included
             end
           end
         when AST::Ruby::Declarations::Base
-          # noop
+          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.normalized_module_entry(module_name) 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.normalized_module_entry(module_name) 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.normalized_module_entry(module_name) 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
 

lib/rbs/errors.rb

@@ -475,31 +475,51 @@ def initialize(type_name:, member:)
       @type_name = type_name
       @member = member
 
-      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member_name(member)}` in the definition of `#{type_name}`"
     end
 
     def location
       member.location
     end
 
     def self.check!(type_name:, env:, member:)
-      if env.class_decl?(member.name)
+      name = case member
+             when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+               member.name
+             when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+               member.module_name
+             else
+               raise "Unknown member type: #{member.class}"
+             end
+      
+      if env.class_decl?(name)
         raise new(type_name: type_name, member: member)
       end
     end
 
     private
 
+    def member_name(member)
+      case member
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        member.name
+      when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+        member.module_name
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def mixin_name
       case member
-      when AST::Members::Prepend
+      when AST::Members::Prepend, AST::Ruby::Members::PrependMember
         "prepend"
-      when AST::Members::Include
+      when AST::Members::Include, AST::Ruby::Members::IncludeMember
         "include"
-      when AST::Members::Extend
+      when AST::Members::Extend, AST::Ruby::Members::ExtendMember
         "extend"
       else
-        raise
+        raise "Unknown member type: #{member.class}"
       end
     end
   end

sig/definition.rbs

@@ -155,6 +155,7 @@ module RBS
         type source = :super     # Inheritance
                     | nil        # Itself
                     | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
+                    | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember  # Ruby AST
                     | AST::Declarations::Module::Self
 
         attr_reader name: TypeName

sig/errors.rbs

@@ -115,14 +115,16 @@ module RBS
   class NoMixinFoundError < DefinitionError
     include DetailedMessageable
 
+    type member = AST::Members::t | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember
+
     attr_reader type_name: TypeName
-    attr_reader member: AST::Members::t
+    attr_reader member: member
 
-    def initialize: (type_name: TypeName, member: AST::Members::t) -> void
+    def initialize: (type_name: TypeName, member: member) -> void
 
     def location: () -> Location[untyped, untyped]?
 
-    def self.check!: (TypeName, env: Environment, member: AST::Members::t) -> void
+    def self.check!: (TypeName, env: Environment, member: member) -> void
   end
 
   class DuplicatedMethodDefinitionError < DefinitionError
@@ -287,6 +289,7 @@ module RBS
     include DetailedMessageable
 
     type member = AST::Members::Include | AST::Members::Prepend | AST::Members::Extend
+                | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::PrependMember | AST::Ruby::Members::ExtendMember
 
     attr_reader type_name: TypeName
     attr_reader member: member
@@ -297,6 +300,8 @@ module RBS
 
     def self.check!: (type_name: TypeName, env: Environment, member: member) -> void
 
+    def member_name: (member) -> TypeName
+
     def mixin_name: () -> String
   end
 

test/rbs/ancestor_builder_test.rb

@@ -1214,4 +1214,85 @@ class Foo
       end
     end
   end
+
+  def test__one_ancestors__ruby_include_extend_prepend
+    SignatureManager.new(system_builtin: true) do |manager|
+      manager.files[Pathname("mixin.rbs")] = <<~EOF
+        module TestMixin
+        end
+      EOF
+
+      manager.ruby_files[Pathname("lib/test.rb")] = <<~EOF
+        module TestMixin
+        end
+
+        class TestClass
+          include TestMixin
+        end
+
+        class TestExtendClass
+          extend TestMixin
+        end
+
+        class TestPrependClass
+          prepend TestMixin
+        end
+      EOF
+
+      manager.build do |env|
+        builder = DefinitionBuilder::AncestorBuilder.new(env: env)
+
+        # Test include
+        builder.one_instance_ancestors(type_name("::TestClass")).tap do |a|
+          assert_equal type_name("::TestClass"), a.type_name
+          assert_equal [], a.params
+
+          assert_equal Ancestor::Instance.new(name: type_name("::Object"), args: [], source: :super), a.super_class
+          assert_equal 1, a.included_modules.size
+          assert_equal type_name("::TestMixin"), a.included_modules[0].name
+          assert_equal [], a.included_modules[0].args
+          assert_instance_of AST::Ruby::Members::IncludeMember, a.included_modules[0].source
+          assert_equal [], a.included_interfaces
+          assert_equal [], a.prepended_modules
+          assert_nil a.extended_modules
+          assert_nil a.extended_interfaces
+          assert_nil a.self_types
+        end
+
+        # Test extend
+        builder.one_singleton_ancestors(type_name("::TestExtendClass")).tap do |a|
+          assert_equal type_name("::TestExtendClass"), a.type_name
+          assert_nil a.params
+
+          assert_equal Ancestor::Singleton.new(name: type_name("::Object")), a.super_class
+          assert_nil a.included_modules
+          assert_nil a.included_interfaces
+          assert_nil a.prepended_modules
+          assert_equal 1, a.extended_modules.size
+          assert_equal type_name("::TestMixin"), a.extended_modules[0].name
+          assert_equal [], a.extended_modules[0].args
+          assert_instance_of AST::Ruby::Members::ExtendMember, a.extended_modules[0].source
+          assert_equal [], a.extended_interfaces
+          assert_nil a.self_types
+        end
+
+        # Test prepend
+        builder.one_instance_ancestors(type_name("::TestPrependClass")).tap do |a|
+          assert_equal type_name("::TestPrependClass"), a.type_name
+          assert_equal [], a.params
+
+          assert_equal Ancestor::Instance.new(name: type_name("::Object"), args: [], source: :super), a.super_class
+          assert_equal [], a.included_modules
+          assert_equal [], a.included_interfaces
+          assert_equal 1, a.prepended_modules.size
+          assert_equal type_name("::TestMixin"), a.prepended_modules[0].name
+          assert_equal [], a.prepended_modules[0].args
+          assert_instance_of AST::Ruby::Members::PrependMember, a.prepended_modules[0].source
+          assert_nil a.extended_modules
+          assert_nil a.extended_interfaces
+          assert_nil a.self_types
+        end
+      end
+    end
+  end
 end