From 9c64f700851013b70a1b31ca7803a78ec8295d97 Mon Sep 17 00:00:00 2001
From: mybys <takuro.miyabayashi@timee.co.jp>
Date: Mon, 3 Aug 2026 10:22:19 +0900
Subject: [PATCH] Restore blockless overloads for optional-block methods

`Array#sum`, `Array#count` and `Hash#transform_keys!` were changed to use
optional blocks (`?{ ... }`) in 4.1. Steep cannot check a block-pass
argument against an optional block: the expected type becomes a union
with `nil`, which the special case for `Proc` values does not cover
(soutaro/steep#1207). As a result `array.sum(&:amount)`,
`array.count(&:even?)` and friends stopped type checking after 4.0.3,
even though the same call with a literal block is fine.

Spell out the blockless overload again so that block-pass arguments match
the overload with a required block, as they did before.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 core/array.rbs                      |  6 ++++--
 core/hash.rbs                       |  3 ++-
 test/typecheck/block_pass/Steepfile |  7 +++++++
 test/typecheck/block_pass/test.rb   | 11 +++++++++++
 4 files changed, 24 insertions(+), 3 deletions(-)
 create mode 100644 test/typecheck/block_pass/Steepfile
 create mode 100644 test/typecheck/block_pass/test.rb

diff --git a/core/array.rbs b/core/array.rbs
index 000dba738a..80ab7ed5a9 100644
--- a/core/array.rbs
+++ b/core/array.rbs
@@ -1427,7 +1427,8 @@ class Array[unchecked out E]
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def count: () ?{ (E element) -> boolish } -> Integer
+  def count: () -> Integer
+           | () { (E element) -> boolish } -> Integer
            | (untyped object) -> Integer # where E: RBS::Ops::_Equal
 
   # <!--
@@ -3734,7 +3735,8 @@ class Array[unchecked out E]
   # *   Array#sum method may not respect method redefinition of "+" methods such
   #     as Integer#+.
   #
-  def sum: (?untyped init) ?{ (E e) -> untyped } -> untyped # This would be usable if we had `where E < Complex`, etc
+  def sum: (?untyped init) -> untyped
+         | (?untyped init) { (E e) -> untyped } -> untyped # This would be usable if we had `where E < Complex`, etc
 
   # <!--
   #   rdoc-file=array.c
diff --git a/core/hash.rbs b/core/hash.rbs
index 871c688895..a5b9d0c7ec 100644
--- a/core/hash.rbs
+++ b/core/hash.rbs
@@ -1983,7 +1983,8 @@ class Hash[unchecked out K, unchecked out V]
   # Values](rdoc-ref:Hash@Methods+for+Transforming+Keys+and+Values).
   #
   def transform_keys!: () -> Enumerator[K, self]
-                     | (hash[K, K] replacements) ?{ (K key) -> K } -> self
+                     | (hash[K, K] replacements) -> self
+                     | (hash[K, K] replacements) { (K key) -> K } -> self
                      | () { (K key) -> K } -> self
 
   # <!--
diff --git a/test/typecheck/block_pass/Steepfile b/test/typecheck/block_pass/Steepfile
new file mode 100644
index 0000000000..77b2334655
--- /dev/null
+++ b/test/typecheck/block_pass/Steepfile
@@ -0,0 +1,7 @@
+D = Steep::Diagnostic
+
+target :test do
+  signature "."
+  check "."
+  configure_code_diagnostics(D::Ruby.all_error)
+end
diff --git a/test/typecheck/block_pass/test.rb b/test/typecheck/block_pass/test.rb
new file mode 100644
index 0000000000..a80129af96
--- /dev/null
+++ b/test/typecheck/block_pass/test.rb
@@ -0,0 +1,11 @@
+# Steep cannot check a block-pass argument against an optional block, because the
+# expected type becomes a union with `nil` (soutaro/steep#1207). Core signatures
+# therefore spell out a blockless overload instead of using `?{ ... }`.
+
+[1, 2, 3].sum(&:to_r)
+[1, 2, 3].sum(0r, &:to_r)
+
+[1, 2, 3].count(&:even?)
+
+hash = { 1 => 2 } #: Hash[Integer, Integer]
+hash.transform_keys!({ 1 => 3 }, &:itself)