Fix @Generic return type lost when method also declares a block param

Pin::Callable#arity_matches? rejected any call missing a block whenever
the method signature had block info attached, even when that info came
from a bare &block formal parameter with no @yield tags. Ruby never
requires callers to pass a block for such a parameter, so this caused
the sole matching signature to be discarded, skipping generic
resolution and leaving the return type as unresolved generic<T>.

Add Pin::Callable#block_required?, true only for RBS-sourced signatures
with a non-optional block ({ ... } vs ?{ ... }), and gate the arity
check on it instead of bare block presence. YARD-derived signatures
have no way to express a required block, so they default to false.

Fixes castwide#1265

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

Author: apiology

lib/solargraph/pin/callable.rb

@@ -14,12 +14,17 @@ class Callable < Closure
       # @param block [Signature, nil]
       # @param return_type [ComplexType, nil]
       # @param parameters [::Array<Pin::Parameter>]
+      # @param block_required [Boolean] Whether callers must pass a block for
+      #   this signature to apply. Only ever true for RBS-sourced signatures
+      #   with a non-optional block (`{ ... }` rather than `?{ ... }`); a bare
+      #   `&block` parameter or YARD @yield tag never makes a block mandatory.
       # @param [Hash{Symbol => Object}] splat
-      def initialize block: nil, return_type: nil, parameters: [], **splat
+      def initialize block: nil, return_type: nil, parameters: [], block_required: false, **splat
         super(**splat)
         @block = block
         @return_type = return_type
         @parameters = parameters
+        @block_required = block_required
       end
 
       def reset_generated!
@@ -55,6 +60,7 @@ def combine_blocks other
       def combine_with other, attrs = {}
         new_attrs = {
           block: combine_blocks(other),
+          block_required: block_required? || other.block_required?,
           return_type: combine_return_type(other)
         }.merge(attrs)
         new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
@@ -241,7 +247,7 @@ def arity_matches? arguments, with_block
         argcount = arguments.length
         parcount = mandatory_positional_param_count
         parcount -= 1 if !parameters.empty? && parameters.last.block?
-        return false if block? && !with_block
+        return false if block? && block_required? && !with_block
         # @todo this and its caller should be changed so that this can
         #   look at the kwargs provided and check names against what
         #   we acccept
@@ -267,6 +273,11 @@ def block?
         !!@block
       end
 
+      # @return [Boolean]
+      def block_required?
+        !!@block_required
+      end
+
       protected
 
       attr_writer :block

lib/solargraph/rbs_map/conversions.rb

@@ -551,7 +551,8 @@ def method_def_to_sigs decl, pin
                     Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs,
                                        type_location: type_location, closure: pin)
                   end
-          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block, source: :rbs,
+          Pin::Signature.new(generics: generics, parameters: signature_parameters, return_type: signature_return_type, block: block,
+                             block_required: overload.method_type.block&.required || false, source: :rbs,
                              type_location: type_location, closure: pin)
         end
       end

lib/solargraph/rbs_translator.rb

@@ -91,7 +91,8 @@ def self.to_signature method_type, closure, parameter_names = []
         block_return_type = to_complex_type(method_type.block.type.return_type)
         Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
       end
-      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, source: :rbs, type_location: closure.location, closure: closure)
+      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block,
+                         block_required: method_type.block&.required || false, source: :rbs, type_location: closure.location, closure: closure)
     end
 
     # @param type_name [RBS::TypeName]

spec/source/chain/call_spec.rb

@@ -280,6 +280,31 @@ def baz
     expect(type.tag).to eq('String')
   end
 
+  it 'infers generic return types from @generic tag when method also takes an unused block param' do
+    source = Solargraph::Source.load_string(%(
+      class Foo
+        def initialize; end
+        def foo_method; 1; end
+      end
+
+      class Repro
+        # @generic T
+        # @param clazz [Class<generic<T>>]
+        # @return [generic<T>]
+        def create_object(clazz, &unused)
+          clazz.new
+        end
+      end
+
+      Repro.new.create_object(Foo)
+    ), 'test.rb')
+    api_map = Solargraph::ApiMap.new
+    api_map.map source
+    chain = Solargraph::Source::SourceChainer.chain(source, Solargraph::Position.new(15, 20))
+    type = chain.infer(api_map, Solargraph::Pin::ROOT_PIN, api_map.source_map('test.rb').locals)
+    expect(type.tag).to eq('Foo')
+  end
+
   it 'infers generic return types from block from yield being a return node' do
     pending('deeper inference support')