From 217c5447c9a6a28be4a3f45df306e3c62869f589 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Mon, 5 Oct 2026 14:57:59 +0900
Subject: [PATCH] Revert IO::Buffer subclass-preserving types and drop
 BufferSubclass tests

ruby-head (5b6f593531, "Introduce (internal) IO::Buffer::Storage and Slice")
removed the allocator from IO::Buffer and made Storage the allocatable
subclass. The test-only `Class.new(IO::Buffer)` subclass can no longer be
instantiated, and IO::Buffer.for/.string reject it, which broke the
stdlib_test job on ruby-head.

Since that design is still internal and likely to change, go back to the
plain `Buffer` types for IO::Buffer.for, .string, #slice and #transfer, and
exercise the remaining `self`-returning methods with plain IO::Buffer
instances. The optional-argument forms of #slice are kept.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 core/io/buffer.rbs            | 10 +++---
 test/stdlib/io/Buffer_test.rb | 68 +++++++++++------------------------
 2 files changed, 26 insertions(+), 52 deletions(-)

diff --git a/core/io/buffer.rbs b/core/io/buffer.rbs
index 285f16a50..c1597ed1d 100644
--- a/core/io/buffer.rbs
+++ b/core/io/buffer.rbs
@@ -124,8 +124,8 @@ class IO
     #       # => "Test"
     #     end
     #
-    def self.for: (string) -> instance
-                | [A] (string) { (instance) -> A } -> A
+    def self.for: (string) -> Buffer
+                | [A] (string) { (Buffer) -> A } -> A
 
     # <!--
     #   rdoc-file=io_buffer.c
@@ -200,7 +200,7 @@ class IO
     #     end
     #     # => "Ruby"
     #
-    def self.string: (int) { (instance) -> void } -> String
+    def self.string: (int) { (Buffer) -> void } -> String
 
     # <!--
     #   rdoc-file=io_buffer.c
@@ -1040,7 +1040,7 @@ class IO
     #     # #<IO::Buffer 0x00007fc3d31e2d80+4 INTERNAL>
     #     # 0x00000000  74 6f 73 74                                     tost
     #
-    def slice: (?Integer? offset, ?Integer? length) -> self
+    def slice: (?Integer? offset, ?Integer? length) -> Buffer
 
     # <!--
     #   rdoc-file=io_buffer.c
@@ -1073,7 +1073,7 @@ class IO
     #     buffer.null?
     #     # => true
     #
-    def transfer: () -> self
+    def transfer: () -> Buffer
 
     # <!--
     #   rdoc-file=io_buffer.c
diff --git a/test/stdlib/io/Buffer_test.rb b/test/stdlib/io/Buffer_test.rb
index 67ff0c242..a23753b1c 100644
--- a/test/stdlib/io/Buffer_test.rb
+++ b/test/stdlib/io/Buffer_test.rb
@@ -20,21 +20,6 @@ def test_for
         "(string) { (IO::Buffer) -> String } -> String",
         IO::Buffer, :for, source
       ) { "result" }
-
-      assert_send_type(
-        "(string) -> IO_Buffer_InstanceTest::BufferSubclass",
-        IO_Buffer_InstanceTest::BufferSubclass, :for, source
-      )
-
-      assert_send_type(
-        "(string) { (IO_Buffer_InstanceTest::BufferSubclass) -> Integer } -> Integer",
-        IO_Buffer_InstanceTest::BufferSubclass, :for, source
-      ) { 42 }
-
-      assert_send_type(
-        "(string) { (IO_Buffer_InstanceTest::BufferSubclass) -> String } -> String",
-        IO_Buffer_InstanceTest::BufferSubclass, :for, source
-      ) { "result" }
     end
   end
 
@@ -79,11 +64,6 @@ def test_string
         "(int) { (IO::Buffer) -> nil } -> String",
         IO::Buffer, :string, int
       ) { nil }
-
-      assert_send_type(
-        "(int) { (IO_Buffer_InstanceTest::BufferSubclass) -> nil } -> String",
-        IO_Buffer_InstanceTest::BufferSubclass, :string, int
-      ) { nil }
     end
   end
 end
@@ -92,8 +72,6 @@ class IO_Buffer_InstanceTest < Test::Unit::TestCase
   include TestHelper
   testing "::IO::Buffer"
 
-  BufferSubclass = Class.new(IO::Buffer)
-
   def test_bitwise_operators
     buffer = IO::Buffer.for("test")
     mask = IO::Buffer.for("\xFF\x00")
@@ -116,14 +94,14 @@ def test_bitwise_mutation
 
     [:and!, :or!, :xor!].each do |operator|
       assert_send_type(
-        "(IO::Buffer) -> IO_Buffer_InstanceTest::BufferSubclass",
-        BufferSubclass.new(4), operator, mask
+        "(IO::Buffer) -> IO::Buffer",
+        IO::Buffer.new(4), operator, mask
       )
     end
 
     assert_send_type(
-      "() -> IO_Buffer_InstanceTest::BufferSubclass",
-      BufferSubclass.new(4), :not!
+      "() -> IO::Buffer",
+      IO::Buffer.new(4), :not!
     )
   end
 
@@ -170,41 +148,41 @@ def test_copy
   end
 
   def test_each
-    buf = BufferSubclass.new(2)
+    buf = IO::Buffer.new(2)
     buf.set_string("ab")
 
     assert_send_type(
-      "() -> Enumerator[[Integer, Integer], IO_Buffer_InstanceTest::BufferSubclass]",
+      "() -> Enumerator[[Integer, Integer], IO::Buffer]",
       buf, :each
     )
     assert_send_type(
-      "(:U8, Integer, Integer) { (Integer, Integer) -> void } -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(:U8, Integer, Integer) { (Integer, Integer) -> void } -> IO::Buffer",
       buf, :each, :U8, 0, 2
     ) { |_, _| }
 
-    float_buf = BufferSubclass.new(8)
+    float_buf = IO::Buffer.new(8)
     float_buf.set_values([:F32, :F32], 0, [1.5, 2.5])
 
     assert_send_type(
-      "(:F32) -> Enumerator[[Integer, Float], IO_Buffer_InstanceTest::BufferSubclass]",
+      "(:F32) -> Enumerator[[Integer, Float], IO::Buffer]",
       float_buf, :each, :F32
     )
     assert_send_type(
-      "(:F32, Integer, Integer) { (Integer, Float) -> void } -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(:F32, Integer, Integer) { (Integer, Float) -> void } -> IO::Buffer",
       float_buf, :each, :F32, 0, 2
     ) { |_, _| }
   end
 
   def test_each_byte
-    buf = BufferSubclass.new(3)
+    buf = IO::Buffer.new(3)
     buf.set_string("abc")
 
     assert_send_type(
-      "() -> Enumerator[Integer, IO_Buffer_InstanceTest::BufferSubclass]",
+      "() -> Enumerator[Integer, IO::Buffer]",
       buf, :each_byte
     )
     assert_send_type(
-      "(Integer, Integer) { (Integer) -> void } -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(Integer, Integer) { (Integer) -> void } -> IO::Buffer",
       buf, :each_byte, 1, 2
     ) { |_| }
   end
@@ -431,34 +409,34 @@ def test_size
   end
 
   def test_slice
-    buf = BufferSubclass.new(30)
+    buf = IO::Buffer.new(30)
 
     assert_send_type(
-      "() -> IO_Buffer_InstanceTest::BufferSubclass",
+      "() -> IO::Buffer",
       buf, :slice
     )
     assert_send_type(
-      "(Integer) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(Integer) -> IO::Buffer",
       buf, :slice, 1
     )
     assert_send_type(
-      "(Integer, Integer) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(Integer, Integer) -> IO::Buffer",
       buf, :slice, 0, 5
     )
     assert_send_type(
-      "(nil) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(nil) -> IO::Buffer",
       buf, :slice, nil
     )
     assert_send_type(
-      "(nil, Integer) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(nil, Integer) -> IO::Buffer",
       buf, :slice, nil, 5
     )
     assert_send_type(
-      "(Integer, nil) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(Integer, nil) -> IO::Buffer",
       buf, :slice, 1, nil
     )
     assert_send_type(
-      "(nil, nil) -> IO_Buffer_InstanceTest::BufferSubclass",
+      "(nil, nil) -> IO::Buffer",
       buf, :slice, nil, nil
     )
   end
@@ -475,10 +453,6 @@ def test_transfer
       "() -> IO::Buffer",
       IO::Buffer.for(""), :transfer
     )
-    assert_send_type(
-      "() -> IO_Buffer_InstanceTest::BufferSubclass",
-      BufferSubclass.new(4), :transfer
-    )
   end
 
   def test_valid?