Revert IO::Buffer subclass-preserving types for ruby-head

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

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?