From 3d0bb6c23675fe3f164d813077883d6d9b607bca Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sat, 25 Jan 2025 23:57:51 +0900
Subject: [PATCH 1/9] Fix bug: Treat nil as a return value

---
 lib/rbs/unit_test/spy.rb | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/rbs/unit_test/spy.rb b/lib/rbs/unit_test/spy.rb
index 9d85da267..a385d410f 100644
--- a/lib/rbs/unit_test/spy.rb
+++ b/lib/rbs/unit_test/spy.rb
@@ -20,6 +20,8 @@ class WrapSpy
         attr_reader :object
         attr_reader :method_name
 
+        NO_RETURN = Object.new
+
         def initialize(object:, method_name:)
           @callback = -> (_) { }
           @object = object
@@ -39,7 +41,7 @@ def wrapped_object
             define_method(
               spy.method_name,
               _ = -> (*args, &block) do
-                return_value = nil
+                return_value = NO_RETURN
                 exception = nil
                 block_calls = [] #: Array[Test::ArgumentsReturn]
 
@@ -105,7 +107,7 @@ def wrapped_object
                       arguments: args,
                       exception: exception
                     )
-                  when return_value
+                  when ::RBS::UnitTest::Spy::WrapSpy::NO_RETURN != return_value
                     Test::ArgumentsReturn.return(
                       arguments: args,
                       value: return_value

From 7fbb8f5b48c98418475b04d51ceae9889a3c5774 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sat, 25 Jan 2025 23:58:47 +0900
Subject: [PATCH 2/9] GC::Profiler.raw_data can be `nil`

---
 core/gc.rbs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/gc.rbs b/core/gc.rbs
index 0fd4512e2..8a4b73dbf 100644
--- a/core/gc.rbs
+++ b/core/gc.rbs
@@ -111,7 +111,7 @@ module GC
     # `:HAVE_FINALIZE`
     # :
     #
-    def self.raw_data: () -> Array[Hash[Symbol, untyped]]
+    def self.raw_data: () -> Array[Hash[Symbol, untyped]]?
 
     # <!--
     #   rdoc-file=gc.c

From a2e76833b111ba110e959b4fa48846a16bdd4bfb Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 00:00:07 +0900
Subject: [PATCH 3/9] Fix test has `%a{implicitly-returns-nil}`

`%a{implicitly-returns-nil}` cannot be checked to return `nil`
---
 test/stdlib/Array_test.rb | 23 ++---------------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/test/stdlib/Array_test.rb b/test/stdlib/Array_test.rb
index c2c9d7a7a..381d05adb 100644
--- a/test/stdlib/Array_test.rb
+++ b/test/stdlib/Array_test.rb
@@ -155,8 +155,6 @@ def test_at
                      [1,2,3], :at, 0
     assert_send_type "(ToInt) -> Integer",
                      [1,2,3], :at, ToInt.new(0)
-    assert_send_type "(ToInt) -> nil",
-                     [1,2,3], :at, ToInt.new(-5)
   end
 
   def test_bsearch
@@ -269,11 +267,8 @@ def test_delete
   def test_delete_at
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :delete_at, 2
-    assert_send_type "(Integer) -> nil",
-                     [1,2,3], :delete_at, 100
-
-    assert_send_type "(ToInt) -> nil",
-                     [1,2,3], :delete_at, ToInt.new(300)
+    assert_send_type "(ToInt) -> Integer",
+                     [1,2,3], :delete_at, ToInt.new(2)
   end
 
   def test_delete_if
@@ -427,8 +422,6 @@ def test_find_index
   def test_first
     assert_send_type "() -> Integer",
                      [1,2,3], :first
-    assert_send_type "() -> nil",
-                     [], :first
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :first, 2
@@ -529,8 +522,6 @@ def test_keep_if
   def test_last
     assert_send_type "() -> Integer",
                      [1,2,3], :last
-    assert_send_type "() -> nil",
-                     [], :last
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :last, 2
@@ -558,8 +549,6 @@ def test_map!
   def test_max
     assert_send_type "() -> Integer",
                      [1,2,3], :max
-    assert_send_type "() -> nil",
-                     [], :max
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :max, 1
@@ -568,8 +557,6 @@ def test_max
 
     assert_send_type "() { (Integer, Integer) -> Integer } -> Integer",
                      [1,2,3], :max do |_, _| 1 end
-    assert_send_type "() { (Integer, Integer) -> Integer } -> nil",
-                     [], :max do |_, _| 0 end
 
     assert_send_type "(ToInt) { (Integer, Integer) -> Integer } -> Array[Integer]",
                      [1,2,3], :max, ToInt.new(2) do |_, _| 0 end
@@ -758,8 +745,6 @@ def test_rotate!
   def test_sample
     assert_send_type "() -> Integer",
                      [1,2,3], :sample
-    assert_send_type "() -> nil",
-                     [], :sample
     assert_send_type "(random: Random) -> Integer",
                      [1,2,3], :sample, random: Random.new(1)
     assert_send_type "(random: Rand) -> Integer",
@@ -817,8 +802,6 @@ def test_shuffle!
   def test_slice
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :slice, 1
-    assert_send_type "(ToInt) -> nil",
-                     [1,2,3], :slice, ToInt.new(11)
 
     assert_send_type "(Integer, Integer) -> Array[Integer]",
                      [1,2,3], :slice, 1, 2
@@ -834,8 +817,6 @@ def test_slice
   def test_slice!
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :slice!, 1
-    assert_send_type "(ToInt) -> nil",
-                     [1,2,3], :slice!, ToInt.new(11)
 
     assert_send_type "(Integer, Integer) -> Array[Integer]",
                      [1,2,3], :slice!, 1, 2

From d39675d12ef9ce7869d611847c33220839d865db Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 00:02:38 +0900
Subject: [PATCH 4/9] Fix to be explicit, including patterns return `nil`

---
 test/stdlib/MatchData_test.rb | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/test/stdlib/MatchData_test.rb b/test/stdlib/MatchData_test.rb
index 1c4e9ef65..024e269e9 100644
--- a/test/stdlib/MatchData_test.rb
+++ b/test/stdlib/MatchData_test.rb
@@ -23,23 +23,27 @@ def test_initalize_copy
 
   def test_bytebegin
     if_ruby("3.4"...) do
-      with_backref do |backref|
-        assert_send_type  '(MatchData::capture) -> Integer',
-                          INSTANCE, :bytebegin, backref
-        assert_send_type  '(MatchData::capture) -> Integer',
-                          INSTANCE2, :bytebegin, backref
-      end
+      assert_send_type '(String) -> Integer',
+                       INSTANCE, :bytebegin, 'a'
+      assert_send_type '(Symbol) -> Integer',
+                       INSTANCE, :bytebegin, :a
+      assert_send_type '(Integer) -> Integer',
+                       INSTANCE2, :bytebegin, 0
+      assert_send_type '(Integer) -> nil',
+                       INSTANCE2, :bytebegin, 1
     end
   end
 
   def test_byteend
     if_ruby("3.4"...) do
-      with_backref do |backref|
-        assert_send_type  '(MatchData::capture) -> Integer',
-                          INSTANCE, :byteend, backref
-        assert_send_type  '(MatchData::capture) -> Integer',
-                          INSTANCE2, :byteend, backref
-      end
+      assert_send_type '(String) -> Integer',
+                       INSTANCE, :byteend, 'a'
+      assert_send_type '(Symbol) -> Integer',
+                       INSTANCE, :byteend, :a
+      assert_send_type '(Integer) -> Integer',
+                       INSTANCE2, :byteend, 0
+      assert_send_type '(Integer) -> nil',
+                       INSTANCE2, :byteend, 1
     end
   end
 

From 9d05f7898155d6884624282e967c1b6337765f63 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 00:03:53 +0900
Subject: [PATCH 5/9] Fix miss testing

```
'\u{e4 f6 fc}'.encode('ISO-8859-1').to_sym.casecmp?(:'\u{c4 d6 dc}')
=> false
```
---
 test/stdlib/Symbol_test.rb | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/test/stdlib/Symbol_test.rb b/test/stdlib/Symbol_test.rb
index c27ac8904..788ea57a8 100644
--- a/test/stdlib/Symbol_test.rb
+++ b/test/stdlib/Symbol_test.rb
@@ -134,17 +134,12 @@ def test_casecmp
   def test_casecmp?
     %i[a A s S z Z].each do |other|
       assert_send_type '(Symbol) -> bool',
-                       :s, :casecmp?, other
-    end
-
-    # invalid encoding
-    assert_send_type '(Symbol) -> nil',
-                     '\u{e4 f6 fc}'.encode('ISO-8859-1').to_sym, :casecmp?, :'\u{c4 d6 dc}'
-
-    with_untyped.and :sym do |other|
-      assert_send_type '(untyped) -> bool?',
-                       :a, :casecmp?, other
+                        :s, :casecmp?, other
     end
+    assert_send_type '(String) -> nil',
+                     :abc, :casecmp?, "abc"
+    assert_send_type '(Integer) -> nil',
+                     :abc, :casecmp?, 1
   end
 
   def test_downcase
@@ -177,7 +172,7 @@ def test_encoding
   def test_end_with?
     assert_send_type '() -> bool',
                      :a, :end_with?
-    
+
     with_string 'a' do |string_a|
       assert_send_type '(string) -> true',
                        :a, :end_with?, string_a

From 80574221ff9dcb770d3eae260e2341d9a9b906b2 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 00:05:18 +0900
Subject: [PATCH 6/9] Fix typing

```
map.getkey(123)
=> nil
```
---
 test/stdlib/ObjectSpace_WeakKeyMap_test.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/stdlib/ObjectSpace_WeakKeyMap_test.rb b/test/stdlib/ObjectSpace_WeakKeyMap_test.rb
index 3e3ea7075..d37f93eb6 100644
--- a/test/stdlib/ObjectSpace_WeakKeyMap_test.rb
+++ b/test/stdlib/ObjectSpace_WeakKeyMap_test.rb
@@ -76,8 +76,8 @@ def test_getkey
     map["foo"] = 123
 
     assert_send_type(
-      "(::Integer) -> ::String",
-      map, :getkey, 123
+      "(::String) -> ::String",
+      map, :getkey, "foo"
     )
     assert_send_type(
       "(::String) -> nil",

From d6135c99ca6562d7dff11de2640f4e7132e71de6 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 13:46:57 +0900
Subject: [PATCH 7/9] Use Pathname v0.4.0

Since the return values of some methods have changed, we use gem to fix the behavior.
---
 Gemfile      | 1 +
 Gemfile.lock | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/Gemfile b/Gemfile
index 82fb13792..ca3cc6f1e 100644
--- a/Gemfile
+++ b/Gemfile
@@ -29,6 +29,7 @@ group :libs do
   gem "dbm"
   gem "mutex_m"
   gem "nkf"
+  gem "pathname"
 end
 
 group :profilers do
diff --git a/Gemfile.lock b/Gemfile.lock
index 734ce72bb..ecad8a786 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -71,6 +71,7 @@ GEM
     parser (3.3.7.0)
       ast (~> 2.4.1)
       racc
+    pathname (0.4.0)
     power_assert (2.0.5)
     pstore (0.1.4)
     psych (4.0.6)
@@ -177,6 +178,7 @@ DEPENDENCIES
   net-smtp
   nkf
   ostruct
+  pathname
   pstore
   raap
   rake

From e3e0b1ef3df6287b5f1166cce348afa87381963e Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Sun, 26 Jan 2025 16:59:17 +0900
Subject: [PATCH 8/9] Fix typing

---
 sig/unit_test/spy.rbs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sig/unit_test/spy.rbs b/sig/unit_test/spy.rbs
index a7ae59ed6..de3f37ddb 100644
--- a/sig/unit_test/spy.rbs
+++ b/sig/unit_test/spy.rbs
@@ -5,6 +5,8 @@ module RBS
                    | [T, S] (untyped object, Symbol method_name) { (WrapSpy[T], T) -> S } -> S
 
       class WrapSpy[T]
+        NO_RETURN: Object
+
         attr_accessor callback: ^(Test::CallTrace) -> void
 
         attr_reader object: T

From d59fa39e7deeaf47151a2f5edd258d1c192b2f05 Mon Sep 17 00:00:00 2001
From: ksss <co000ri@gmail.com>
Date: Mon, 27 Jan 2025 23:36:05 +0900
Subject: [PATCH 9/9] Allow `nil` if annotated `implicitly-returns-nil`

---
 lib/rbs/test/type_check.rb           | 12 +++++++-----
 lib/rbs/unit_test/type_assertions.rb | 28 +++++++++++++++++-----------
 sig/test/type_check.rbs              |  4 ++--
 sig/unit_test/type_assertions.rbs    |  2 ++
 test/stdlib/Array_test.rb            | 27 +++++++++++++++++++++++++--
 5 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/lib/rbs/test/type_check.rb b/lib/rbs/test/type_check.rb
index a24fd290e..be83873b3 100644
--- a/lib/rbs/test/type_check.rb
+++ b/lib/rbs/test/type_check.rb
@@ -22,8 +22,8 @@ def initialize(self_class:, builder:, sample_size:, unchecked_classes:, instance
       end
 
       def overloaded_call(method, method_name, call, errors:)
-        es = method.method_types.map do |method_type|
-          es = method_call(method_name, method_type, call, errors: [])
+        es = method.defs.map do |type_def|
+          es = method_call(method_name, type_def.type, call, errors: [], annotations: type_def.annotations)
 
           if es.empty?
             return errors
@@ -58,11 +58,11 @@ def overloaded_call(method, method_name, call, errors:)
         errors
       end
 
-      def method_call(method_name, method_type, call, errors:)
+      def method_call(method_name, method_type, call, errors:, annotations: [])
         return errors if method_type.type.is_a?(Types::UntypedFunction)
 
         args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
-        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
+        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError, annotations:)
 
         if method_type.block
           case
@@ -106,8 +106,10 @@ def args(method_name, method_type, fun, call, errors, type_error:, argument_erro
         end
       end
 
-      def return(method_name, method_type, fun, call, errors, return_error:)
+      def return(method_name, method_type, fun, call, errors, return_error:, annotations: [])
         if call.return?
+          return if Test.call(call.return_value, IS_AP, NilClass) && annotations.find { |a| a.string == "implicitly-returns-nil" }
+
           unless value(call.return_value, fun.return_type)
             errors << return_error.new(klass: self_class,
                                        method_name: method_name,
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index fff0f68b7..33d73f5e4 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -163,7 +163,7 @@ def send_setup(method_type, receiver, method, args, proc)
           end
         end
 
-        last_trace = trace.last or raise
+        last_trace = trace.last or raise "empty trace"
 
         yield(mt, last_trace, result, exception)
       end
@@ -182,9 +182,9 @@ def send_setup(method_type, receiver, method, args, proc)
 
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           raise exception if exception
 
@@ -219,30 +219,36 @@ def send_setup(method_type, receiver, method, args, proc)
           assert_operator exception, :is_a?, ::Exception
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           result
         end
       end
 
-      def method_types(method)
+      def method_defs(method)
         type, definition = target
 
         case type
         when Types::ClassInstance
           subst = RBS::Substitution.build(definition.type_params, type.args)
-          definition.methods[method].method_types.map do |method_type|
-            method_type.sub(subst)
+          definition.methods[method].defs.map do |type_def|
+            type_def.update(
+              type: type_def.type.sub(subst)
+            )
           end
         when Types::ClassSingleton
-          definition.methods[method].method_types
+          definition.methods[method].defs
         else
           raise
         end
       end
 
+      def method_types(method)
+        method_defs(method).map(&:type)
+      end
+
       def allows_error(*errors)
         yield
       rescue *errors => exn
diff --git a/sig/test/type_check.rbs b/sig/test/type_check.rbs
index 1a503dd43..ad1306b44 100644
--- a/sig/test/type_check.rbs
+++ b/sig/test/type_check.rbs
@@ -7,12 +7,12 @@ module RBS
       #
       # Returns an array with detected errors.
       #
-      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t]) -> Array[Errors::t]
+      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t], ?annotations: Array[AST::Annotation]) -> Array[Errors::t]
 
       # Test if given `value` is compatible to type
       #
       # Returns `true` if the value has the type.
-      # 
+      #
       def value: (untyped value, Types::t) -> bool
     end
   end
diff --git a/sig/unit_test/type_assertions.rbs b/sig/unit_test/type_assertions.rbs
index 44d13caf6..3fb1ed9fd 100644
--- a/sig/unit_test/type_assertions.rbs
+++ b/sig/unit_test/type_assertions.rbs
@@ -104,6 +104,8 @@ module RBS
       #
       def class_class: () -> Class
 
+      def method_defs: (Symbol) -> Array[Definition::Method::TypeDef]
+
       def method_types: (Symbol) -> Array[MethodType]
 
       def allows_error: (*Exception) { () -> void } -> void
diff --git a/test/stdlib/Array_test.rb b/test/stdlib/Array_test.rb
index 381d05adb..4165b3e76 100644
--- a/test/stdlib/Array_test.rb
+++ b/test/stdlib/Array_test.rb
@@ -88,6 +88,8 @@ def test_lshift
   def test_aref
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :[], 0
+    assert_send_type "(Integer) -> nil",
+                     [1,2,3], :[], 1000
     assert_send_type "(Float) -> Integer",
                      [1,2,3], :[], 0.1
     assert_send_type "(ToInt) -> Integer",
@@ -155,6 +157,8 @@ def test_at
                      [1,2,3], :at, 0
     assert_send_type "(ToInt) -> Integer",
                      [1,2,3], :at, ToInt.new(0)
+    assert_send_type "(ToInt) -> nil",
+                     [1,2,3], :at, ToInt.new(-5)
   end
 
   def test_bsearch
@@ -267,8 +271,11 @@ def test_delete
   def test_delete_at
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :delete_at, 2
-    assert_send_type "(ToInt) -> Integer",
-                     [1,2,3], :delete_at, ToInt.new(2)
+    assert_send_type "(Integer) -> nil",
+                     [1,2,3], :delete_at, 100
+
+    assert_send_type "(ToInt) -> nil",
+                     [1,2,3], :delete_at, ToInt.new(300)
   end
 
   def test_delete_if
@@ -422,6 +429,8 @@ def test_find_index
   def test_first
     assert_send_type "() -> Integer",
                      [1,2,3], :first
+    assert_send_type "() -> nil",
+                     [], :first
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :first, 2
@@ -522,6 +531,8 @@ def test_keep_if
   def test_last
     assert_send_type "() -> Integer",
                      [1,2,3], :last
+    assert_send_type "() -> nil",
+                     [], :last
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :last, 2
@@ -549,6 +560,8 @@ def test_map!
   def test_max
     assert_send_type "() -> Integer",
                      [1,2,3], :max
+    assert_send_type "() -> nil",
+                     [], :max
 
     assert_send_type "(Integer) -> Array[Integer]",
                      [1,2,3], :max, 1
@@ -557,6 +570,8 @@ def test_max
 
     assert_send_type "() { (Integer, Integer) -> Integer } -> Integer",
                      [1,2,3], :max do |_, _| 1 end
+    assert_send_type "() { (Integer, Integer) -> Integer } -> nil",
+                     [], :max do |_, _| 0 end
 
     assert_send_type "(ToInt) { (Integer, Integer) -> Integer } -> Array[Integer]",
                      [1,2,3], :max, ToInt.new(2) do |_, _| 0 end
@@ -745,6 +760,8 @@ def test_rotate!
   def test_sample
     assert_send_type "() -> Integer",
                      [1,2,3], :sample
+    assert_send_type "() -> nil",
+                     [], :sample
     assert_send_type "(random: Random) -> Integer",
                      [1,2,3], :sample, random: Random.new(1)
     assert_send_type "(random: Rand) -> Integer",
@@ -779,6 +796,8 @@ def test_shift
                      [1,2,3], :shift
     assert_send_type "(ToInt) -> Array[Integer]",
                      [1,2,3], :shift, ToInt.new(1)
+    assert_send_type "() -> nil",
+                     [], :shift
   end
 
   def test_shuffle
@@ -802,6 +821,8 @@ def test_shuffle!
   def test_slice
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :slice, 1
+    assert_send_type "(ToInt) -> nil",
+                     [1,2,3], :slice, ToInt.new(11)
 
     assert_send_type "(Integer, Integer) -> Array[Integer]",
                      [1,2,3], :slice, 1, 2
@@ -817,6 +838,8 @@ def test_slice
   def test_slice!
     assert_send_type "(Integer) -> Integer",
                      [1,2,3], :slice!, 1
+    assert_send_type "(ToInt) -> nil",
+                     [1,2,3], :slice!, ToInt.new(11)
 
     assert_send_type "(Integer, Integer) -> Array[Integer]",
                      [1,2,3], :slice!, 1, 2