Implement RBS prepend support with comprehensive tests

This commit adds full support for RBS::AST::Members::Prepend to properly handle
prepended modules in type checking and method resolution.

Key changes:
- Add SigPrependNode class to handle prepend declarations
- Separate prepended_modules from included_modules in ModuleEntity
- Fix method resolution order: prepended modules → class → included modules
- Update type compatibility checking to recognize prepended modules
- Fix prepend module ordering (last prepended = first in ancestor chain)
- Add break after finding first matching prepended method

Testing:
- Add test for basic prepend functionality
- Add test for multiple prepended modules
- Add test for prepend and include combination

This ensures that when a class prepends a module, instances of that class
are correctly recognized as compatible with the module type, and methods
from prepended modules properly override class methods following Ruby semantics.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: 2 people

lib/typeprof/core/ast.rb

@@ -400,6 +400,8 @@ def self.create_rbs_member(raw_decl, lenv)
         SigDefNode.new(raw_decl, lenv)
       when RBS::AST::Members::Include
         SigIncludeNode.new(raw_decl, lenv)
+      when RBS::AST::Members::Prepend
+        SigPrependNode.new(raw_decl, lenv)
       when RBS::AST::Members::Extend
       when RBS::AST::Members::Public
       when RBS::AST::Members::Private

lib/typeprof/core/ast/sig_decl.rb

@@ -255,6 +255,55 @@ def install0(genv)
       end
     end
 
+    class SigPrependNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        name = raw_decl.name
+        @cpath = name.namespace.path + [name.name]
+        @toplevel = name.namespace.absolute?
+        @args = raw_decl.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+      end
+
+      attr_reader :cpath, :toplevel, :args
+      def subnodes = { args: }
+      def attrs = { cpath:, toplevel: }
+
+      def define0(genv)
+        @args.each {|arg| arg.define(genv) }
+        const_reads = []
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
+        const_reads << const_read
+        @cpath[1..].each do |cname|
+          const_read = ScopedConstRead.new(cname, const_read, false)
+          const_reads << const_read
+        end
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        const_read.followers << mod
+        mod.add_prepend_decl(genv, self)
+        const_reads
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.add_prepend_decl(genv, self)
+        mod.remove_prepend_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.remove_prepend_decl(genv, self)
+        @static_ret.each do |const_read|
+          const_read.destroy(genv)
+        end
+        @args.each {|arg| arg.undefine(genv) }
+      end
+
+      def install0(genv)
+        Source.new
+      end
+    end
+
     class SigAliasNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)

lib/typeprof/core/env/module_entity.rb

@@ -7,6 +7,8 @@ def initialize(cpath, outer_module = self)
       @module_defs = Set[]
       @include_decls = Set[]
       @include_defs = Set[]
+      @prepend_decls = []
+      @prepend_defs = []
 
       @inner_modules = {}
       @outer_module = outer_module
@@ -15,6 +17,7 @@ def initialize(cpath, outer_module = self)
       @superclass = nil
       @self_types = {}
       @included_modules = {}
+      @prepended_modules = {}
       @basic_object = @cpath == [:BasicObject]
 
       # child modules (subclasses and all modules that include me)
@@ -46,6 +49,7 @@ def initialize(cpath, outer_module = self)
     attr_reader :superclass
     attr_reader :self_types
     attr_reader :included_modules
+    attr_reader :prepended_modules
     attr_reader :child_modules
 
     attr_reader :superclass_type_args
@@ -192,6 +196,26 @@ def remove_include_def(genv, node)
       genv.add_static_eval_queue(:parent_modules_changed, self)
     end
 
+    def add_prepend_decl(genv, node)
+      @prepend_decls << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_prepend_decl(genv, node)
+      @prepend_decls.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def add_prepend_def(genv, node)
+      @prepend_defs << node
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
+    def remove_prepend_def(genv, node)
+      @prepend_defs.delete(node) || raise
+      genv.add_static_eval_queue(:parent_modules_changed, self)
+    end
+
     def update_parent(genv, origin, old_parent, new_parent_cpath)
       new_parent = new_parent_cpath ? genv.resolve_cpath(new_parent_cpath) : nil
       if old_parent != new_parent
@@ -323,6 +347,30 @@ def on_parent_modules_changed(genv)
           any_updated = true
         end
       end
+      @prepend_decls.each do |pdecl|
+        new_parent_cpath = pdecl.static_ret.last.cpath
+        new_parent, updated = update_parent(genv, pdecl, @prepended_modules[pdecl], new_parent_cpath)
+        if updated
+          if new_parent
+            @prepended_modules[pdecl] = new_parent
+          else
+            @prepended_modules.delete(pdecl) || raise
+          end
+          any_updated = true
+        end
+      end
+      @prepend_defs.each do |pdef|
+        new_parent_cpath = pdef.static_ret ? pdef.static_ret.cpath : nil
+        new_parent, updated = update_parent(genv, pdef, @prepended_modules[pdef], new_parent_cpath)
+        if updated
+          if new_parent
+            @prepended_modules[pdef] = new_parent
+          else
+            @prepended_modules.delete(pdef) || raise
+          end
+          any_updated = true
+        end
+      end
       @included_modules.delete_if do |origin, old_mod|
         if @include_decls.include?(origin) || @include_defs.include?(origin)
           false
@@ -332,6 +380,15 @@ def on_parent_modules_changed(genv)
           true
         end
       end
+      @prepended_modules.delete_if do |origin, old_mod|
+        if @prepend_decls.include?(origin) || @prepend_defs.include?(origin)
+          false
+        else
+          _new_parent, updated = update_parent(genv, origin, old_mod, nil)
+          any_updated ||= updated
+          true
+        end
+      end
 
       if any_updated
         @subclass_checks.each do |mcall_box|

lib/typeprof/core/graph/box.rb

@@ -786,6 +786,16 @@ def resolve(genv, changes, &blk)
         alias_limit = 0
         while ty
           unless skip
+            # First check prepended modules
+            if !ty.is_a?(Type::Singleton)
+              if resolve_prepended_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
+                  yield me, ty, mid, orig_ty
+                end
+                break
+              end
+            end
+
+            # Then check the class/module itself
             me = ty.mod.get_method(ty.is_a?(Type::Singleton), mid)
             changes.add_depended_method_entity(me) if changes
             if !me.aliases.empty?
@@ -804,6 +814,7 @@ def resolve(genv, changes, &blk)
           if ty.is_a?(Type::Singleton)
             # TODO: extended modules
           else
+            # Finally check included modules
             break if resolve_included_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
               yield me, ty, mid, orig_ty
             end
@@ -816,6 +827,38 @@ def resolve(genv, changes, &blk)
       end
     end
 
+    def resolve_prepended_modules(genv, changes, base_ty_env, ty, mid, &blk)
+      found = false
+
+      alias_limit = 0
+      # Process prepended modules in reverse order (last prepended = first in ancestor chain)
+      ty.mod.prepended_modules.reverse_each do |prep_decl, prep_mod|
+        if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
+          prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, base_ty_env, ty)
+        else
+          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          prep_ty = Type::Instance.new(genv, prep_mod, type_params)
+        end
+
+        me = prep_ty.mod.get_method(false, mid)
+        changes.add_depended_method_entity(me) if changes
+        if !me.aliases.empty?
+          mid = me.aliases.values.first
+          alias_limit += 1
+          redo if alias_limit < 5
+        end
+        if me.exist?
+          found = true
+          yield me, prep_ty, mid
+        else
+          found = resolve_prepended_modules(genv, changes, base_ty_env, prep_ty, mid, &blk)
+        end
+        break if found
+      end
+
+      found
+    end
+
     def resolve_included_modules(genv, changes, base_ty_env, ty, mid, &blk)
       found = false
 

lib/typeprof/core/type.rb

@@ -107,6 +107,7 @@ def check_match(genv, changes, vtx)
               changes.add_depended_superclass(ty.mod)
 
               if other_ty.mod.module?
+                return true if check_match_prepended_modules(genv, changes, ty, other_ty)
                 return true if check_match_included_modules(genv, changes, ty, other_ty)
               end
 
@@ -117,6 +118,32 @@ def check_match(genv, changes, vtx)
         return false
       end
 
+      def check_match_prepended_modules(genv, changes, ty, other_ty)
+        ty.mod.prepended_modules.each do |prep_decl, prep_mod|
+          if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
+            prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, {}, ty)
+          else
+            type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+            prep_ty = Type::Instance.new(genv, prep_mod, type_params)
+          end
+          if prep_ty.mod == other_ty.mod
+            args_all_match = true
+            prep_ty.args.zip(other_ty.args) do |arg, other_arg|
+              if other_arg && !arg.check_match(genv, changes, other_arg)
+                args_all_match = false
+                break
+              end
+            end
+            return true if args_all_match
+          end
+          changes.add_depended_superclass(prep_ty.mod)
+
+          return true if check_match_prepended_modules(genv, changes, prep_ty, other_ty)
+          return true if check_match_included_modules(genv, changes, prep_ty, other_ty)
+        end
+        return false
+      end
+
       def check_match_included_modules(genv, changes, ty, other_ty)
         ty.mod.included_modules.each do |inc_decl, inc_mod|
           if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params

scenario/rbs/prepend.rb

@@ -0,0 +1,29 @@
+## update: test.rbs
+module M
+  def foo: () -> String
+end
+
+class C
+  prepend M
+
+  def foo: () -> Integer
+end
+
+class Object
+  def accept_m: (M) -> String
+end
+
+## update: test.rb
+def test
+  accept_m(C.new)
+end
+
+def test2
+  C.new.foo
+end
+
+## assert
+class Object
+  def test: -> String
+  def test2: -> String
+end

scenario/rbs/prepend_include_mix.rb

@@ -0,0 +1,48 @@
+## update: test.rbs
+module M1
+  def foo: () -> :m1
+end
+
+module M2
+  def foo: () -> :m2
+  def bar: () -> :m2
+end
+
+module M3
+  def foo: () -> :m3
+  def bar: () -> :m3
+  def baz: () -> :m3
+end
+
+class C
+  include M1
+  prepend M2
+  include M3
+
+  def foo: () -> :c
+  def bar: () -> :c
+  def baz: () -> :c
+end
+
+## update: test.rb
+def test_foo
+  # Should return :m2 (prepended module wins)
+  C.new.foo
+end
+
+def test_bar
+  # Should return :m2 (prepended module wins)
+  C.new.bar
+end
+
+def test_baz
+  # Should return :c (class method overrides included module)
+  C.new.baz
+end
+
+## assert
+class Object
+  def test_foo: -> :m2
+  def test_bar: -> :m2
+  def test_baz: -> :c
+end

scenario/rbs/prepend_multiple.rb

@@ -0,0 +1,47 @@
+## update: test.rbs
+module M1
+  def foo: () -> :m1
+end
+
+module M2
+  def foo: () -> :m2
+  def bar: () -> :m2
+end
+
+class C
+  prepend M1
+  prepend M2
+
+  def foo: () -> :c
+  def bar: () -> :c
+end
+
+class Object
+  def accept_m1: (M1) -> String
+  def accept_m2: (M2) -> String
+end
+
+## update: test.rb
+def test_foo
+  C.new.foo
+end
+
+def test_bar
+  C.new.bar
+end
+
+def test_type_m1
+  accept_m1(C.new)
+end
+
+def test_type_m2
+  accept_m2(C.new)
+end
+
+## assert
+class Object
+  def test_foo: -> :m2
+  def test_bar: -> :m2
+  def test_type_m1: -> String
+  def test_type_m2: -> String
+end