Introduce InterfaceType for rbs interface and type alias resolution

rbs HEAD uses type aliases (range[T], array[U], etc.) in core method
signatures where concrete classes and interfaces used to appear, which
broke completion. Resolve type aliases from their definitions with
expand_alias2 instead of mapping known alias names, and represent rbs
interfaces as InterfaceType instead of falling back to Object. Interface
types provide completion candidates from the interface definition, bind
type variables through named_params, and match argument types by duck
typing in overload scoring.

Also fix RBS::Types::Bases::Class conversion that discarded the transform
result and referenced an undefined variable.

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

Author: tompng

lib/repl_type_completor/type_analyzer.rb

@@ -1152,7 +1152,7 @@ def method_call(receiver, method_name, args, kwargs, block, scope, name_match: t
       methods = Types.rbs_methods receiver, method_name.to_sym, args, kwargs, !!block
       block_called = false
       type_breaks = methods.map do |method, given_params, method_params|
-        receiver_vars = receiver.is_a?(Types::InstanceType) ? receiver.named_params : {}
+        receiver_vars = receiver.is_a?(Types::InstanceType) || receiver.is_a?(Types::InterfaceType) ? receiver.named_params : {}
         free_vars = method.type.free_variables - receiver_vars.keys.to_set
         vars = receiver_vars.merge Types.match_free_variables(free_vars, method_params, given_params)
         if block && method.block && method.block.type.respond_to?(:required_positionals)

lib/repl_type_completor/types.rb

@@ -75,6 +75,11 @@ def self.rbs_absolute_type_name(name)
     def self.rbs_search_method(klass, method_name, singleton)
       return unless rbs_builder
 
+      if klass.is_a? InterfaceType
+        definition = klass.definition
+        return definition && definition.methods[method_name]
+      end
+
       klass.ancestors.each do |ancestor|
         next unless (name = Methods::MODULE_NAME_METHOD.bind_call(ancestor))
 
@@ -93,6 +98,8 @@ def self.method_return_type(type, method_name)
           [t, t.module_or_class, true]
         in InstanceType
           [t, t.klass, false]
+        in InterfaceType
+          [t, t, false]
         end
       end
       types = receivers.flat_map do |receiver_type, klass, singleton|
@@ -115,6 +122,8 @@ def self.accessor_method_return_type(type, method_name)
           t.module_or_class
         in InstanceType
           t.instances
+        in InterfaceType
+          nil
         end
       end.flatten
       instances = instances.sample(OBJECT_TO_TYPE_SAMPLE_SIZE) if instances.size > OBJECT_TO_TYPE_SAMPLE_SIZE
@@ -136,6 +145,8 @@ def self.rbs_methods(type, method_name, args_types, kwargs_type, has_block)
           [t, t.module_or_class, true]
         in InstanceType
           [t, t.klass, false]
+        in InterfaceType
+          [t, t, false]
         end
       end
       has_splat = args_types.include?(nil)
@@ -193,7 +204,14 @@ def self.intersect?(a, b)
       end
 
       aa, bb = [atypes, btypes].map {|types| (types[InstanceType] || []).map(&:klass) }
-      (aa.flat_map(&:ancestors) & bb).any?
+      return true if (aa.flat_map(&:ancestors) & bb).any?
+
+      [[atypes[InterfaceType], b], [btypes[InterfaceType], a]].any? do |interfaces, other|
+        interfaces&.any? do |interface|
+          methods = interface.methods
+          !methods.empty? && other.types.any? { |t| (methods - t.methods).empty? }
+        end
+      end
     end
 
     def self.type_from_object(object)
@@ -340,6 +358,38 @@ def inspect_without_params
       end
     end
 
+    class InterfaceType
+      attr_reader :name, :args
+
+      def initialize(name, args = [])
+        @name = name
+        @args = args
+      end
+
+      def definition
+        return @definition if defined?(@definition)
+
+        @definition = (Types.rbs_builder&.build_interface(@name) rescue nil)
+      end
+
+      def transform() = yield(self)
+      def methods() = definition ? definition.methods.keys : []
+      def all_methods() = methods
+
+      def named_params
+        definition ? definition.type_params.zip(@args).to_h.compact : {}
+      end
+
+      def constants() = []
+      def types() = [self]
+      def nillable?() = false
+      def nonnillable() = self
+
+      def inspect
+        args.empty? ? name.name.to_s : "#{name.name}[#{args.map(&:inspect).join(', ')}]"
+      end
+    end
+
     NIL = InstanceType.new NilClass
     OBJECT = InstanceType.new Object
     TRUE = InstanceType.new TrueClass
@@ -364,6 +414,7 @@ class UnionType
       def initialize(*types)
         @types = []
         singleton_types = []
+        interface_types = {}
         instance_types = {}
         collect = -> type do
           case type
@@ -377,10 +428,12 @@ def initialize(*types)
             end
           in SingletonType
             singleton_types << type
+          in InterfaceType
+            interface_types[[type.name, type.args]] ||= type
           end
         end
         types.each(&collect)
-        @types = singleton_types.uniq + instance_types.map do |klass, (params, instances)|
+        @types = singleton_types.uniq + interface_types.values + instance_types.map do |klass, (params, instances)|
           params = params.map { |v| UnionType[*v] }
           InstanceType.new(klass, params, instances)
         end
@@ -434,12 +487,13 @@ def self.from_rbs_type(return_type, self_type, extra_vars = {})
         self_type.transform do |type|
           case type
           in SingletonType
-            InstanceType.new(self_type.module_or_class.is_a?(Class) ? Class : Module)
+            InstanceType.new(type.module_or_class.is_a?(Class) ? Class : Module)
           in InstanceType
             SingletonType.new type.klass
+          in InterfaceType
+            CLASS
           end
         end
-        UnionType[*types]
       when RBS::Types::Bases::Bool
         BOOLEAN
       when RBS::Types::Bases::Instance
@@ -467,11 +521,11 @@ def self.from_rbs_type(return_type, self_type, extra_vars = {})
       when RBS::Types::Variable
         if extra_vars.key? return_type.name
           extra_vars[return_type.name]
-        elsif self_type.is_a? InstanceType
+        elsif self_type.is_a?(InstanceType) || self_type.is_a?(InterfaceType)
           self_type.named_params[return_type.name] || OBJECT
         elsif self_type.is_a? UnionType
           types = self_type.types.filter_map do |t|
-            t.named_params[return_type.name] if t.is_a? InstanceType
+            t.named_params[return_type.name] if t.is_a?(InstanceType) || t.is_a?(InterfaceType)
           end
           UnionType[*types]
         else
@@ -480,20 +534,11 @@ def self.from_rbs_type(return_type, self_type, extra_vars = {})
       when RBS::Types::Optional
         UnionType[from_rbs_type(return_type.type, self_type, extra_vars), NIL]
       when RBS::Types::Alias
-        case return_type.name.name
-        when :int
-          INTEGER
-        when :boolish
-          BOOLEAN
-        when :string
-          STRING
-        else
-          # TODO: ???
-          OBJECT
-        end
+        expanded = (rbs_builder.expand_alias2 return_type.name, return_type.args rescue nil)
+        expanded ? from_rbs_type(expanded, self_type, extra_vars) : OBJECT
       when RBS::Types::Interface
-        # unimplemented
-        OBJECT
+        args = return_type.args.map { from_rbs_type _1, self_type, extra_vars }
+        InterfaceType.new return_type.name, args
       when RBS::Types::ClassInstance
         klass = return_type.name.to_namespace.path.reduce(Object) { _1.const_get _2 }
         if return_type.args
@@ -553,6 +598,13 @@ def self._match_free_variable(vars, rbs_type, value, accumulator)
           values = ac[from]
           (accumulator[to] ||= []).concat values if values
         end
+      in [RBS::Types::Union,]
+        rbs_type.types.each do |t|
+          _match_free_variable vars, t, value, accumulator
+        end
+      in [RBS::Types::Alias,]
+        expanded = rbs_builder.expand_alias2 rbs_type.name, rbs_type.args rescue nil
+        _match_free_variable vars, expanded, value, accumulator if expanded
       else
       end
     end

test/repl_type_completor/test_type_analyze.rb

@@ -774,6 +774,8 @@ def test_block_args
     def test_array_aref
       assert_call('[1][0..].', include: [Array, NilClass], exclude: Integer)
       assert_call('[1][0].', include: Integer, exclude: [Array, NilClass])
+      # Float matches the `int` index param by duck typing (Float#to_int)
+      assert_call('[1][0.5].', include: Integer, exclude: Array)
       assert_call('[1].[](0).', include: Integer, exclude: [Array, NilClass])
       assert_call('[1].[](0){}.', include: Integer, exclude: [Array, NilClass])
     end

test/repl_type_completor/test_types.rb

@@ -94,6 +94,32 @@ def foobar; end
       assert_include type.all_methods, :rand
     end
 
+    def type_from_rbs(rbs_string)
+      ReplTypeCompletor::Types.load_rbs_builder unless ReplTypeCompletor::Types.rbs_builder
+      rbs_type = RBS::Parser.parse_type(rbs_string)
+      ReplTypeCompletor::Types.from_rbs_type(rbs_type, ReplTypeCompletor::Types::OBJECT)
+    end
+
+    def test_interface_type
+      to_int = type_from_rbs('::_ToInt')
+      assert_equal '_ToInt', to_int.inspect
+      assert_equal [:to_int], to_int.methods
+      assert ReplTypeCompletor::Types.intersect?(ReplTypeCompletor::Types::FLOAT, to_int)
+      assert ReplTypeCompletor::Types.intersect?(to_int, ReplTypeCompletor::Types::FLOAT)
+      refute ReplTypeCompletor::Types.intersect?(ReplTypeCompletor::Types::STRING, to_int)
+
+      to_ary = type_from_rbs('::_ToAry[::Integer]')
+      assert_equal '_ToAry[Integer]', to_ary.inspect
+      return_type = ReplTypeCompletor::Types.method_return_type(to_ary, :to_ary)
+      assert_equal Array, return_type.klass
+      assert_equal Integer, return_type.params[0].klass
+    end
+
+    def test_alias_type_expansion
+      int_type = type_from_rbs('::int')
+      assert_equal 'Integer | _ToInt', int_type.inspect
+    end
+
     def test_basic_object_methods
       bo = BasicObject.new
       def bo.foobar; end