Align type params in AncestorBuilder#validate_super_class!

The superclass comparison across multiple declarations compared the
superclass args as written, so declarations that declare the same
superclass with different type parameter names (`class C[A] < Base[A]`
and `class C[B] < Base[B]`) raised a false SuperclassMismatchError.
Align the args to the entry's type parameter names before comparing,
like ModuleEntry#self_types and mixin_ancestors do.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TBY8ct4HpkVkZNPdsNHEDE

Author: claude

lib/rbs/definition_builder/ancestor_builder.rb

@@ -177,9 +177,22 @@ def validate_super_class!(type_name, entry)
 
         return if with_super_classes.size <= 1
 
+        entry_param_names = entry.type_params.map(&:name)
+
         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)
+          args = super_class.args
+
+          decl_param_names = decl.type_params.map(&:name)
+          unless decl_param_names == entry_param_names || args.empty?
+            align_params = Substitution.build(
+              decl_param_names,
+              entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+            )
+            args = args.map {|type| type.sub(align_params) }
+          end
+
+          Types::ClassInstance.new(name: super_class.name, args: args, location: nil)
         end
 
         super_types.uniq!

test/rbs/ancestor_builder_test.rb

@@ -452,6 +452,45 @@ class B < ::String
     end
   end
 
+  def test_instance_ancestors_super_class_validation_renamed_params
+    SignatureManager.new do |manager|
+      manager.files.merge!(Pathname("foo.rbs") => <<-EOF)
+class Base[T]
+end
+
+class A[X] < Base[X]
+end
+
+class B[X] < Base[X]
+end
+
+class B[Y] < Base[Integer]
+end
+      EOF
+
+      manager.files.merge!(Pathname("foo2.rbs") => <<-EOF)
+class A[Y] < Base[Y]
+end
+      EOF
+
+      manager.build do |env|
+        builder = DefinitionBuilder::AncestorBuilder.new(env: env)
+
+        # ::A is valid: the declarations declare the same superclass modulo type parameter renaming.
+        builder.one_instance_ancestors(type_name("::A")).tap do |a|
+          assert_equal Ancestor::Instance.new(name: type_name("::Base"), args: [parse_type("X", variables: [:X])], source: :super),
+                       a.super_class
+        end
+
+        # ::B is invalid: the superclass args are different.
+        error = assert_raises SuperclassMismatchError do
+          builder.one_instance_ancestors(type_name("::B"))
+        end
+        assert_equal error.name, type_name("::B")
+      end
+    end
+  end
+
   def test_singleton_ancestors
     SignatureManager.new do |manager|
       manager.files[Pathname("foo.rbs")] = <<EOF