Merge castwide#1266: structurally verify RBS interface-typed expectations

Two conflicts resolved:

lib/solargraph/complex_type/conformance.rb: HEAD's intersection-type
check (from castwide#1231, `conforms_to_intersection_expectation?`) and castwide#1266's
new `interface_bypass_verdict` mechanism both needed to run, in that
order — an expectation of `A & B` where either conjunct is an RBS
interface must still resolve the interface question per-conjunct, not
skip it. `interface_bypass_verdict` replaces the old blanket
`:allow_unmatched_interface` short-circuit with a 3-way verdict
(true/false/nil) based on `structural_interface_verdict`, deferring to
the old blanket bypass only when no structural verdict can be reached.

spec/complex_type/conforms_to_spec.rb:
- Dropped a `pending 'nil does not yet simplify to NilClass (issue
  castwide#1196, fixed by PR castwide#1223)'` marker after confirming directly
  (`inf.conforms_to?(api_map, exp, :method_call)` => true) that castwide#1223,
  already merged into this branch, fixes it.
- Combined HEAD's `context 'with intersection types'` (castwide#1231) and
  castwide#1266's `context 'with RBS interface types'` as sibling contexts
  rather than choosing one; kept castwide#1266's two `pending` markers for
  issue castwide#1267 (structural interface checks don't yet verify return
  types/arity) as-is since those are castwide#1266's own honest, still-open
  limitations.

Verified: spec/complex_type/conforms_to_spec.rb + spec/complex_type
(56 examples, 0 failures, 4 pending), and a broader safety net —
spec/type_checker, spec/source_map/clip_spec.rb,
spec/parser/flow_sensitive_typing_spec.rb (539 examples, 0 failures,
17 pending) — all passing locally.

Author: apiology

lib/solargraph/complex_type/conformance.rb

@@ -47,7 +47,9 @@ def conforms_to_unique_type?
         # satisfying both).
         return conforms_to_intersection_expectation? if expected.is_a?(UniqueType::Intersection)
 
-        return true if ignore_interface?
+        interface_verdict = interface_bypass_verdict
+        return interface_verdict unless interface_verdict.nil?
+
         return true if conforms_via_reverse_match?
 
         downcast_inferred = inferred.downcast_to_literal_if_possible
@@ -107,9 +109,34 @@ def conforms_via_stripped_expected_parameters?
         with_new_types(inferred, expected.erase_parameters).conforms_to_unique_type?
       end
 
-      def ignore_interface?
-        (expected.any?(&:interface?) && rules.include?(:allow_unmatched_interface)) ||
-          (inferred.interface? && rules.include?(:allow_unmatched_interface))
+      # Resolves interface-typed conformance before any parameter/subtype
+      # comparisons run, the same way the old blanket
+      # :allow_unmatched_interface bypass did. That's deliberate: RBS
+      # interfaces can have their own type parameters (e.g. `_Each[Elem]`),
+      # and this doesn't verify those (see
+      # https://github.com/castwide/solargraph/issues/1267), so once the
+      # interface question is settled, comparing `expected`'s subtypes
+      # against `inferred`'s would either be meaningless or wrong.
+      #
+      # There's no structural check when the *inferred* type is itself an
+      # abstract interface (e.g., a method returns `_ToAry`), since
+      # Solargraph doesn't know which concrete type will show up at
+      # runtime, so :allow_unmatched_interface remains a blanket escape
+      # hatch for that direction.
+      #
+      # @return [Boolean, nil] true/false if the interface question
+      #   settles conformance outright, nil if there's no interface
+      #   involved (or no verdict could be reached and no fallback rule
+      #   applies), meaning normal conformance checking should proceed
+      def interface_bypass_verdict
+        return true if inferred.interface? && rules.include?(:allow_unmatched_interface)
+        return nil unless expected.interface?
+
+        verdict = structural_interface_verdict
+        return verdict unless verdict.nil?
+        return true if rules.include?(:allow_unmatched_interface)
+
+        nil
       end
 
       def can_strip_expected_parameters?
@@ -148,6 +175,26 @@ def erased_type_conforms?
         true
       end
 
+      # The methods `expected` declares directly on itself, excluding ones
+      # inherited from `Object` and other ancestors.
+      #
+      # @return [Array<Pin::Method>]
+      def required_interface_methods
+        api_map.get_methods(expected.name, scope: :instance)
+               .select { |pin| pin.closure&.path == expected.name }
+      end
+
+      # @return [Boolean, nil] true or false if `expected`'s directly
+      #   declared methods could be checked against `inferred`'s method
+      #   stack, or nil if no verdict could be reached (e.g., the interface
+      #   has no pin, or declares no methods of its own)
+      def structural_interface_verdict
+        required = required_interface_methods
+        return nil if required.empty?
+
+        required.all? { |pin| !api_map.get_method_stack(inferred.name, pin.name, scope: :instance).empty? }
+      end
+
       def key_types_conform?
         return true if expected.key_types.empty?
 

spec/complex_type/conforms_to_spec.rb

@@ -355,6 +355,88 @@ def to_str
     end
   end
 
+  context 'with RBS interface types' do
+    it 'structurally validates a type that satisfies the interface, without any rule' do
+      exp = described_class.parse('Hash::_Key')
+      inf = described_class.parse('Symbol')
+      match = inf.conforms_to?(api_map, exp, :method_call)
+      expect(match).to be(true)
+    end
+
+    it 'structurally invalidates a type that does not satisfy the interface, even with allow_unmatched_interface' do
+      exp = described_class.parse('_ToAry')
+      inf = described_class.parse('Integer')
+      match = inf.conforms_to?(api_map, exp, :method_call, [:allow_unmatched_interface])
+      expect(match).to be(false)
+    end
+
+    it 'rejects a type that does not satisfy the interface when the rule is absent' do
+      exp = described_class.parse('_ToAry')
+      inf = described_class.parse('Integer')
+      match = inf.conforms_to?(api_map, exp, :method_call)
+      expect(match).to be(false)
+    end
+
+    it 'validates a type that satisfies the interface via a core fill include' do
+      exp = described_class.parse('_ToAry')
+      inf = described_class.parse('Array')
+      match = inf.conforms_to?(api_map, exp, :method_call)
+      expect(match).to be(true)
+    end
+
+    it 'falls back to allow_unmatched_interface when the interface pin cannot be found' do
+      exp = described_class::UniqueType.new('_NoSuchInterface', rooted: true)
+      inf = described_class.parse('Integer')
+      expect(inf.conforms_to?(api_map, exp, :method_call, [:allow_unmatched_interface])).to be(true)
+      expect(inf.conforms_to?(api_map, exp, :method_call)).to be(false)
+    end
+
+    it 'rejects a same-named method with the wrong return type' do
+      # https://github.com/castwide/solargraph/issues/1267
+      #
+      # The structural check only confirms a `to_ary` method exists; it
+      # doesn't verify it actually returns an Array.
+      pending 'structural interface conformance does not yet check method return types (issue #1267)'
+      source = Solargraph::Source.load_string(%(
+        class BadToAry
+          # @return [String]
+          def to_ary
+            'not an array'
+          end
+        end
+      ))
+      api_map.map source
+      exp = described_class.parse('_ToAry')
+      inf = described_class.parse('BadToAry')
+      match = inf.conforms_to?(api_map, exp, :method_call)
+      expect(match).to be(false)
+    end
+
+    it 'rejects a same-named method with the wrong arity' do
+      # https://github.com/castwide/solargraph/issues/1267
+      #
+      # The structural check only confirms an `eql?` method exists; it
+      # doesn't verify it accepts the argument Hash::_Key#eql? requires.
+      pending 'structural interface conformance does not yet check method parameters (issue #1267)'
+      source = Solargraph::Source.load_string(%(
+        class BadKey
+          def eql?
+            true
+          end
+
+          def hash
+            1
+          end
+        end
+      ))
+      api_map.map source
+      exp = described_class.parse('Hash::_Key')
+      inf = described_class.parse('BadKey')
+      match = inf.conforms_to?(api_map, exp, :method_call)
+      expect(match).to be(false)
+    end
+  end
+
   context 'with inheritance relationship in allow_reverse_match mode' do
     let(:api_map) { Solargraph::ApiMap.new }
     let(:sup) { described_class.parse('String') }