From ebc88d73e3a6fa11194a2e606f817f5f42412a71 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Wed, 25 Mar 2026 19:08:15 -0700
Subject: [PATCH 01/11] Singleton methods done

---
 core/module.rbs                   |  8 ++++----
 test/stdlib/Module_test.rb        | 28 ++++++++++++++++++++++++----
 test/stdlib/Module_test_helper.rb | 12 ++++++++++++
 3 files changed, 40 insertions(+), 8 deletions(-)
 create mode 100644 test/stdlib/Module_test_helper.rb

diff --git a/core/module.rbs b/core/module.rbs
index b585bc43c..46852bad7 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -19,7 +19,7 @@
 #     Mod.constants          #=> [:CONST, :PI, :E]
 #     Mod.instance_methods   #=> [:meth]
 #
-class Module < Object
+class Module
   # <!--
   #   rdoc-file=eval.c
   #   - Module.constants   -> array
@@ -40,7 +40,7 @@ class Module < Object
   #
   # The second form calls the instance method `constants`.
   #
-  def self.constants: () -> ::Array[Integer]
+  def self.constants: (?boolish inherit) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=eval.c
@@ -56,7 +56,7 @@ class Module < Object
   #     $a           #=> [M1::M2, M1]
   #     $a[0].name   #=> "M1::M2"
   #
-  def self.nesting: () -> ::Array[Module]
+  def self.nesting: () -> Array[Module]
 
   # <!--
   #   rdoc-file=eval.c
@@ -83,7 +83,7 @@ class Module < Object
   #
   #     [B, A]
   #
-  def self.used_modules: () -> ::Array[Module]
+  def self.used_modules: () -> Array[Module]
 
   # <!--
   #   rdoc-file=eval.c
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index d4b285333..73339f17c 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -1,4 +1,5 @@
 require_relative "test_helper"
+require_relative 'Module_test_helper'
 
 class ModuleSingletonTest < Test::Unit::TestCase
   include TestHelper
@@ -8,13 +9,32 @@ class ModuleSingletonTest < Test::Unit::TestCase
   def test_used_modules
     assert_send_type "() -> Array[Module]",
                      Module, :used_modules
+
+    assert_type 'Array[Module]',
+                ModuleTestHelperRefinement::USED_MODULES
   end
 
   def test_used_refinements
-    assert_send_type(
-      "() -> Array[Refinement]",
-      Module, :used_refinements
-    )
+    assert_send_type "() -> Array[Refinement]",
+                     Module, :used_refinements
+
+    assert_type 'Array[Refinement]',
+                ModuleTestHelperRefinement::USED_REFINEMENTS
+  end
+
+  def test_constants
+    assert_send_type '() -> Array[Symbol]',
+                     Module, :constants
+
+    with_boolish do |inherit|
+      assert_send_type '(boolish) -> Array[Symbol]',
+                       Module, :constants, inherit
+    end
+  end
+
+  def test_nesting
+    assert_send_type '() -> Array[Module]',
+                     Module, :nesting
   end
 end
 
diff --git a/test/stdlib/Module_test_helper.rb b/test/stdlib/Module_test_helper.rb
new file mode 100644
index 000000000..113481a76
--- /dev/null
+++ b/test/stdlib/Module_test_helper.rb
@@ -0,0 +1,12 @@
+# Because refinements are scoped per-file, we have to make a separate file to
+# query refinements, so they don't mess up the rest of the `Module_test`.
+module ModuleTestHelperRefinement
+  refine Class.new do
+    def blah = 34
+  end
+end
+
+using ModuleTestHelperRefinement
+
+ModuleTestHelperRefinement::USED_MODULES = Module.used_modules
+ModuleTestHelperRefinement::USED_REFINEMENTS = Module.used_refinements

From 2481c7735255b1b4093130e680c70b4d3d1f837d Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Wed, 25 Mar 2026 19:19:58 -0700
Subject: [PATCH 02/11] added all the untested methods as omits

---
 core/module.rbs            |   4 +-
 test/stdlib/Module_test.rb | 255 +++++++++++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+), 2 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 46852bad7..1d55b9de8 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -162,7 +162,7 @@ class Module
   #     # Class File has no relationship to class String.
   #               File <=> String     # => nil
   #
-  def <=>: (untyped other) -> Integer?
+  def <=>: (untyped other) -> (-1 | 0 | 1)?
 
   # <!--
   #   rdoc-file=object.c
@@ -1821,7 +1821,7 @@ class Module
   # modules, this is the name. For singletons, we show information on the thing
   # we're attached to as well.
   #
-  def inspect: () -> String
+  alias inspect to_s
 
   # <!--
   #   rdoc-file=object.c
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 73339f17c..1cb235906 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -50,6 +50,61 @@ def foo(meth, *args, &block)
     end
   end
 
+  def test_op_lt
+    with Object, Float, Hash do |mod|
+      assert_send_type  '(Module) -> bool?',
+                        Numeric, :<, mod
+    end
+  end
+
+  def test_op_le
+    with Object, Float, Hash do |mod|
+      assert_send_type  '(Module) -> bool?',
+                        Numeric, :<=, mod
+    end
+  end
+
+  def test_op_gt
+    with Object, Float, Hash do |mod|
+      assert_send_type  '(Module) -> bool?',
+                        Numeric, :>, mod
+    end
+  end
+
+  def test_op_ge
+    with Object, Float, Hash do |mod|
+      assert_send_type  '(Module) -> bool?',
+                        Numeric, :>=, mod
+    end
+  end
+
+  def test_op_cmp
+    with Object, Float, Numeric, Hash do |mod|
+      assert_send_type  '(untyped) -> (-1 | 0 | 1)?',
+                        Numeric, :<=>, mod
+    end
+
+    with_untyped do |untyped|
+      next if Module === untyped
+      assert_send_type  '(untyped) -> nil',
+                        Numeric, :<=>, untyped
+    end
+  end
+
+  def test_op_eq
+    with_untyped.and Numeric, Module do |untyped|
+      assert_send_type  '(untyped) -> bool',
+                        Numeric, :==, untyped
+    end
+  end
+
+  def test_op_eqq
+    with_untyped.and Numeric, Module do |untyped|
+      assert_send_type  '(untyped) -> bool',
+                        Numeric, :===, untyped
+    end
+  end
+
   def test_include
     assert_send_type "(Module) -> Module",
                      Module.new, :include, Module.new
@@ -457,4 +512,204 @@ def test_set_temporary_name
       mod, :set_temporary_name, nil
     )
   end
+
+  def test_to_s(method: :to_s)
+    omit 'todo'
+  end
+
+  def test_inspect
+    test_to_s(method: :inspcet)
+  end
+
+  def test_ancestors
+    omit 'todo'
+  end
+
+  def test_autoload
+    omit 'todo'
+  end
+
+  def test_autoload
+    omit 'todo'
+  end
+
+  def test_class_variable_defined
+    omit 'todo'
+  end
+
+  def test_class_variable_get
+    omit 'todo'
+  end
+
+  def test_class_variable_set
+    omit 'todo'
+  end
+
+  def test_class_variables
+    omit 'todo'
+  end
+
+  def test_const_defined
+    omit 'todo'
+  end
+
+  def test_const_get
+    omit 'todo'
+  end
+
+  def test_const_missing
+    omit 'todo'
+  end
+
+  def test_const_set
+    omit 'todo'
+  end
+
+  def test_define_method
+    omit 'todo'
+  end
+
+  def test_deprecate_constant
+    omit 'todo'
+  end
+
+  def test_freeze
+    omit 'todo'
+  end
+
+  def test_included_modules
+    omit 'todo'
+  end
+
+  def test_initialize
+    omit 'todo'
+  end
+
+  def test_initialize_clone
+    omit 'todo'
+  end
+
+  def test_instance_method
+    omit 'todo'
+  end
+
+  def test_instance_methods
+    omit 'todo'
+  end
+
+  def test_method_defined
+    omit 'todo'
+  end
+
+  def test_module_exec
+    omit 'todo'
+  end
+
+  def test_name
+    omit 'todo'
+  end
+
+  def test_private_constant
+    omit 'todo'
+  end
+
+  def test_private_instance_methods
+    omit 'todo'
+  end
+
+  def test_private_method_defined
+    omit 'todo'
+  end
+
+  def test_protected_instance_methods
+    omit 'todo'
+  end
+
+  def test_protected_method_defined
+    omit 'todo'
+  end
+
+  def test_public_constant
+    omit 'todo'
+  end
+
+  def test_public_instance_method
+    omit 'todo'
+  end
+
+  def test_public_instance_methods
+    omit 'todo'
+  end
+
+  def test_public_method_defined
+    omit 'todo'
+  end
+
+  def test_remove_class_variable
+    omit 'todo'
+  end
+
+  def test_remove_method
+    omit 'todo'
+  end
+
+  def test_singleton_class
+    omit 'todo'
+  end
+
+  def test_undef_method
+    omit 'todo'
+  end
+
+  def test_undefined_instance_methods
+    omit 'todo'
+  end
+
+  def test_append_features
+    omit 'todo' # private
+  end
+
+  def test_const_added
+    omit 'todo' # private
+  end
+
+  def test_extend_object
+    omit 'todo' # private
+  end
+
+  def test_extended
+    omit 'todo' # private
+  end
+
+  def test_included
+    omit 'todo' # private
+  end
+
+  def test_method_added
+    omit 'todo' # private
+  end
+
+  def test_method_removed
+    omit 'todo' # private
+  end
+
+  def test_method_undefined
+    omit 'todo' # private
+  end
+
+  def test_prepend_features
+    omit 'todo' # private
+  end
+
+  def test_prepended
+    omit 'todo' # private
+  end
+
+  def test_remove_const
+    omit 'todo' # private
+  end
+
+  def test_using
+    omit 'todo' # private
+  end
 end

From 44fc1d833ae6c3d69814b1640240917328659c42 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Wed, 25 Mar 2026 19:33:52 -0700
Subject: [PATCH 03/11] partway done with the already builtin unit tests; just
 finished const_source_location

---
 core/module.rbs                      |  4 +-
 lib/rbs/unit_test/type_assertions.rb |  4 ++
 test/stdlib/Module_test.rb           | 72 +++++++++++++++++-----------
 3 files changed, 51 insertions(+), 29 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 1d55b9de8..1b2cee489 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -862,7 +862,7 @@ class Module
   # -->
   # Invokes Module.append_features on each parameter in reverse order.
   #
-  def include: (Module, *Module arg0) -> self
+  def include: (Module module, *Module additional_modules) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1240,7 +1240,7 @@ class Module
   # -->
   # Invokes Module.prepend_features on each parameter in reverse order.
   #
-  def prepend: (Module, *Module arg0) -> self
+  def prepend: (Module module, *Module additional_modules) -> self
 
   # <!--
   #   rdoc-file=eval.c
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index d274343fa..632b97487 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -296,6 +296,10 @@ def assert_const_type(type, constant_name)
         assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
       end
 
+      def assert_visibility(vis, receiver, method)
+        omit 'TODO: visibility for types'
+      end
+
       def assert_type(type, value)
         typecheck = RBS::Test::TypeCheck.new(
           self_class: value.class,
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 1cb235906..3f8030c4a 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -50,6 +50,11 @@ def foo(meth, *args, &block)
     end
   end
 
+  module RefinedModule
+    refine String do
+    end
+  end
+
   def test_op_lt
     with Object, Float, Hash do |mod|
       assert_send_type  '(Module) -> bool?',
@@ -108,50 +113,63 @@ def test_op_eqq
   def test_include
     assert_send_type "(Module) -> Module",
                      Module.new, :include, Module.new
-    assert_send_type "(Module, Module) -> Module",
+    assert_send_type "(Module, *Module) -> Module",
                      Module.new, :include, Module.new, Module.new
   end
 
   def test_prepend
     assert_send_type "(Module) -> Module",
                      Module.new, :prepend, Module.new
-    assert_send_type "(Module, Module) -> Module",
+    assert_send_type "(Module, *Module) -> Module",
                      Module.new, :prepend, Module.new, Module.new
   end
 
   def test_refine
     assert_send_type "(Module) { () -> void } -> Refinement",
-                     Foo, :refine, String do nil end
+                     RefinedModule, :refine, Integer do nil end
+
+    assert_visibility :private,
+                      RefinedModule, :refine
   end
 
   def test_refinements
-    assert_send_type(
-      "() -> Array[Refinement]",
-      Foo, :refinements
-    )
+    assert_send_type "() -> Array[Refinement]",
+                     Module.new, :refinements
+
+    assert_send_type "() -> Array[Refinement]",
+                     RefinedModule, :refinements
   end
 
   def test_const_source_location
-    assert_send_type "(Symbol) -> [String, Integer]",
-                     Foo, :const_source_location, :BAR
-    assert_send_type "(Symbol) -> nil",
-                     Foo, :const_source_location, :UNKNOWN
-    assert_send_type "(String) -> [String, Integer]",
-                     Foo, :const_source_location, "BAR"
-    assert_send_type "(String) -> nil",
-                     Foo, :const_source_location, "UNKNOWN"
-    assert_send_type "(Symbol, true) -> [String, Integer]",
-                     Foo, :const_source_location, :BAR, true
-    assert_send_type "(String, nil) -> [String, Integer]",
-                     Foo, :const_source_location, "BAR", nil
-    assert_send_type "(Symbol) -> [ ]",
-                     Foo, :const_source_location, :String
-    assert_send_type "(String) -> [ ]",
-                     Foo, :const_source_location, "String"
-    assert_send_type "(Symbol, true) -> [ ]",
-                     Foo, :const_source_location, :String, true
-    assert_send_type "(String, nil) -> nil",
-                     Foo, :const_source_location, "String", nil
+    with_interned :BAR do |interned|
+      assert_send_type "(interned) -> [String, Integer]",
+                       Foo, :const_source_location, interned
+
+      with_boolish.and_nil do |boolish|
+        assert_send_type "(interned, boolish) -> [String, Integer]",
+                         Foo, :const_source_location, interned, boolish
+      end
+    end
+
+    with_interned :UNKNOWN do |interned|
+      assert_send_type "(interned) -> nil",
+                       Foo, :const_source_location, interned
+
+      with_boolish.and_nil do |boolish|
+        assert_send_type "(interned, boolish) -> nil",
+                         Foo, :const_source_location, interned, boolish
+      end
+    end
+
+    with_interned :String do |interned|
+      assert_send_type "(interned) -> []",
+                       Foo, :const_source_location, interned
+
+      with_boolish.and_nil do |boolish|
+        assert_send_type "(interned, boolish) -> []?",
+                         Foo, :const_source_location, interned, boolish
+      end
+    end
   end
 
   def test_module_eval

From 479ff0a60a3919d46fe8a3a256e97b98ceb33afa Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Thu, 26 Mar 2026 13:32:24 -0700
Subject: [PATCH 04/11] Finished polishing the already-extant methods

---
 core/module.rbs            |  77 +++---
 test/stdlib/Module_test.rb | 495 +++++++++++++++++--------------------
 2 files changed, 270 insertions(+), 302 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 1b2cee489..321389aa5 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -253,7 +253,7 @@ class Module
   #
   #     Exiting with code 99
   #
-  def alias_method: (interned new_name, interned old_name) -> ::Symbol
+  def alias_method: (interned new_name, interned old_name) -> Symbol
 
   # <!--
   #   rdoc-file=object.c
@@ -302,7 +302,7 @@ class Module
   #     end
   #     Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]
   #
-  def attr_accessor: (*interned arg0) -> Array[Symbol]
+  def attr_accessor: (*interned names) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=object.c
@@ -316,7 +316,7 @@ class Module
   # in turn. String arguments are converted to symbols. Returns an array of
   # defined method names as symbols.
   #
-  def attr_reader: (*interned arg0) -> Array[Symbol]
+  def attr_reader: (*interned names) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=object.c
@@ -327,7 +327,7 @@ class Module
   # *symbol*`.id2name`. String arguments are converted to symbols. Returns an
   # array of defined method names as symbols.
   #
-  def attr_writer: (*interned arg0) -> Array[Symbol]
+  def attr_writer: (*interned names) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=load.c
@@ -396,8 +396,7 @@ class Module
   #     dummy:123:in `module_eval': undefined local variable
   #         or method `code' for Thing:Class
   #
-  def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                | [U] () { (self m) [self: self] -> U } -> U
+  alias class_eval module_eval
 
   # <!-- rdoc-file=vm_eval.c -->
   # Evaluates the given block in the context of the class/module. The method
@@ -416,7 +415,7 @@ class Module
   #
   #     Hello there!
   #
-  def class_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U
+  alias class_exec module_exec
 
   # <!--
   #   rdoc-file=object.c
@@ -1155,8 +1154,8 @@ class Module
   #     dummy:123:in `module_eval': undefined local variable
   #         or method `code' for Thing:Class
   #
-  def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                 | [U] () { (self m) [self: self] -> U } -> U
+  def module_eval: (string code, ?string? filename, ?int lineno) -> untyped
+                 | [U] () { (self mod) [self: self] -> U } -> U
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -1222,9 +1221,11 @@ class Module
   #
   private def module_function: () -> nil
                              | (Symbol method_name) -> Symbol
-                             | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
-                             | (string method_name) -> string
-                             | (interned, interned, *interned method_name) -> Array[interned]
+                             | [T < _ToStr] (T method_name) -> T
+                             | (interned method_name) -> interned
+                             | (Symbol, Symbol, *Symbol method_names) -> Array[Symbol]
+                             | [T < _ToStr] (T, T, *T method_names) -> Array[T]
+                             | (interned, interned, *interned method_names) -> Array[interned]
 
   # <!--
   #   rdoc-file=object.c
@@ -1299,10 +1300,14 @@ class Module
   #
   private def private: () -> nil
                      | (Symbol method_name) -> Symbol
-                     | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
-                     | (string method_name) -> string
-                     | (interned, interned, *interned method_name) -> Array[interned]
-                     | (Array[interned]) -> Array[interned]
+                     | [T < _ToStr] (T method_name) -> T
+                     | (interned method_name) -> interned
+                     | (Symbol, Symbol, *Symbol method_names) -> Array[Symbol]
+                     | [T < _ToStr] (T, T, *T method_names) -> Array[T]
+                     | (interned, interned, *interned method_names) -> Array[interned]
+                     | (Array[Symbol] method_names) -> Array[Symbol]
+                     | [T < _ToStr] (Array[T] method_names) -> Array[T]
+                     | (Array[interned] method_names) -> Array[interned]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1324,8 +1329,8 @@ class Module
   #       end
   #     end
   #
-  def private_class_method: (*interned arg0) -> self
-                          | (Array[interned] arg0) -> self
+  def private_class_method: (*interned method_names) -> self
+                          | (Array[interned] method_names) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1440,10 +1445,14 @@ class Module
   #
   private def protected: () -> nil
                        | (Symbol method_name) -> Symbol
-                       | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
-                       | (string method_name) -> string
-                       | (interned, interned, *interned method_name) -> Array[interned]
-                       | (Array[interned]) -> Array[interned]
+                       | [T < _ToStr] (T method_name) -> T
+                       | (interned method_name) -> interned
+                       | (Symbol, Symbol, *Symbol method_names) -> Array[Symbol]
+                       | [T < _ToStr] (T, T, *T method_names) -> Array[T]
+                       | (interned, interned, *interned method_names) -> Array[interned]
+                       | (Array[Symbol] method_names) -> Array[Symbol]
+                       | [T < _ToStr] (Array[T] method_names) -> Array[T]
+                       | (Array[interned] method_names) -> Array[interned]
 
   # <!--
   #   rdoc-file=object.c
@@ -1500,10 +1509,14 @@ class Module
   #
   private def public: () -> nil
                     | (Symbol method_name) -> Symbol
-                    | (Symbol, Symbol, *Symbol method_name) -> Array[Symbol]
-                    | (string method_name) -> string
-                    | (interned, interned, *interned method_name) -> Array[interned]
-                    | (Array[interned]) -> Array[interned]
+                    | [T < _ToStr] (T method_name) -> T
+                    | (interned method_name) -> interned
+                    | (Symbol, Symbol, *Symbol method_names) -> Array[Symbol]
+                    | [T < _ToStr] (T, T, *T method_names) -> Array[T]
+                    | (interned, interned, *interned method_names) -> Array[interned]
+                    | (Array[Symbol] method_names) -> Array[Symbol]
+                    | [T < _ToStr] (Array[T] method_names) -> Array[T]
+                    | (Array[interned] method_names) -> Array[interned]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1516,8 +1529,8 @@ class Module
   # String arguments are converted to symbols. An Array of Symbols and/or Strings
   # is also accepted.
   #
-  def public_class_method: (*interned arg0) -> self
-                         | (Array[interned] arg0) -> self
+  def public_class_method: (*interned method_names) -> self
+                         | (Array[interned] method_names) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1681,7 +1694,7 @@ class Module
   # of the `foo` method using the above approach will change so that the method
   # does not pass through keywords.
   #
-  private def ruby2_keywords: (*interned method_name) -> nil
+  private def ruby2_keywords: (interned method_name, *interned more_method_names) -> nil
 
   # <!--
   #   rdoc-file=object.c
@@ -1730,7 +1743,7 @@ class Module
   #     C::M.name #=> "C::M"
   #     c.new # => #<C:0x0....>
   #
-  def set_temporary_name: (string?) -> self
+  def set_temporary_name: (string? name) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1834,8 +1847,8 @@ class Module
   # `attr_reader(name)` but deprecated. Returns an array of defined method names
   # as symbols.
   #
-  def attr: %a{deprecated} (interned, bool) -> Array[Symbol]
-          | (*interned arg0) -> Array[Symbol]
+  def attr: %a{deprecated} (interned name, bool create_writer) -> Array[Symbol]
+          | (*interned names) -> Array[Symbol]
 
   # A previous incarnation of `interned` for backward-compatibility (see #1499)
   %a{deprecated: Use `interned`}
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 3f8030c4a..ba29dfbbb 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -172,16 +172,29 @@ def test_const_source_location
     end
   end
 
-  def test_module_eval
-    assert_send_type "(String) -> nil",
-                     Foo, :module_eval, 'nil'
-    assert_send_type "(String, String) -> nil",
-                     Foo, :module_eval, 'nil', __FILE__
-    assert_send_type "(String, String, Integer) -> nil",
-                     Foo, :module_eval, 'nil', __FILE__, 42
+  def test_module_eval(method: :module_eval)
+    with_string 'nil' do |code|
+      assert_send_type "(string) -> untyped",
+                       Foo, method, code
+
+      with_string.and_nil do |file|
+        assert_send_type "(string, string?) -> untyped",
+                         Foo, method, code, file
+
+        with_int do |lineno|
+          assert_send_type "(string, string?, int) -> untyped",
+                           Foo, method, code, file, lineno
+        end
+      end
+    end
+
+    assert_send_type '() { (Module) [self: Foo] -> Rational } -> Rational',
+                      Foo, method do 1r end
+  end
 
-    assert_send_type "() { (Module) -> nil } -> nil",
-                     Foo, :module_eval do nil end
+  def test_module_exec(method: :module_exec)
+    assert_send_type '(*String) { (*String) [self: Foo] -> Integer } -> Integer',
+                      Foo, method, '1', '2' do |*x| x.join.to_i end
   end
 
   def test_module_function
@@ -191,44 +204,52 @@ def foo; end
       def bar; end
     end
 
-    assert_send_type(
-      "() -> nil",
-      mod, :module_function
-    )
-    assert_send_type(
-      "(Symbol) -> Symbol",
-      mod, :module_function, :foo
-    )
-    assert_send_type(
-      "(String) -> String",
-      mod, :module_function, "foo"
-    )
-    assert_send_type(
-      "(ToStr) -> ToStr",
-      mod, :module_function, ToStr.new("foo")
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol | String]",
-      mod, :module_function, :foo, "bar"
-    )
+    assert_visibility :private,
+                      mod, :module_function
+
+    # No arguments
+    assert_send_type  '() -> nil',
+                      mod, :module_function
+
+    # Single argument
+    assert_send_type  '(Symbol) -> Symbol',
+                      mod, :module_function, :foo
+
+    with_string 'foo' do |foo|
+      assert_send_type  '[T < _ToStr] (T) -> T',
+                        mod, :module_function, foo
+    end
+
+    with_interned 'foo' do |foo|
+      assert_send_type  '(interned) -> interned',
+                        mod, :module_function, foo
+    end
+
+    # Multiple arguments
+    assert_send_type  '(Symbol, *Symbol) -> Array[Symbol]',
+                      mod, :module_function, :foo, :bar
+
+    with_string 'foo' do |foo|
+      with_string 'bar' do |bar|
+        assert_send_type  '[T < _ToStr] (T, *T) -> Array[T]',
+                          mod, :module_function, foo, bar
+      end
+    end
+
+    with_interned 'foo' do |foo|
+      with_interned 'bar' do |bar|
+        assert_send_type  '(interned, *interned) -> Array[interned]',
+                          mod, :module_function, foo, bar
+      end
+    end
   end
 
   def test_class_eval
-    assert_send_type "(String) -> nil",
-                     Foo, :class_eval, 'nil'
-    assert_send_type "(String, String) -> nil",
-                     Foo, :class_eval, 'nil', __FILE__
-    assert_send_type "(String, String, Integer) -> nil",
-                     Foo, :class_eval, 'nil', __FILE__, 42
-
-    assert_send_type "() { (Module) -> nil } -> nil",
-                     Foo, :class_eval do nil end
+    test_module_eval(method: :class_eval)
   end
 
   def test_class_exec
-    assert_send_type '(*String) { (*String) [self: Foo] -> Integer } -> Integer',
-                      Foo, :class_exec, '1', '2' do |*x| x.join.to_i end
+    test_module_exec(method: :class_exec)
   end
 
   def test_alias_method
@@ -237,298 +258,236 @@ def foo
       end
     end
 
-    omit_if(mod.alias_method(:bar, :foo).equal?(mod))
-    assert_send_type '(::Symbol new_name, ::Symbol old_name) -> ::Symbol',
-                     mod, :alias_method, :bar2, :foo
-    assert_send_type '(::String new_name, ::String old_name) -> ::Symbol',
-                     mod, :alias_method, 'bar3', 'foo'
+    with_interned :bar do |new_name|
+      with_interned :foo do |old_name|
+        assert_send_type  '(interned, interned) -> Symbol',
+                          mod, :alias_method, new_name, old_name
+      end
+    end
   end
 
-  def test_private
+  # Helper for `private`, `public`, and `protected`, as they all function identically
+  def visibility_helper(visibility)
     mod = Module.new do
       def foo; end
 
       def bar; end
     end
 
-    assert_send_type(
-      "() -> nil",
-      mod, :private
-    )
-    assert_send_type(
-      "(Symbol) -> Symbol",
-      mod, :private, :foo
-    )
-    assert_send_type(
-      "(String) -> String",
-      mod, :private, "foo"
-    )
-    assert_send_type(
-      "(ToStr) -> ToStr",
-      mod, :private, ToStr.new("foo")
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[interned]",
-      mod, :private, :foo, "bar"
-    )
-
-    assert_send_type(
-      "(Array[Symbol | String]) -> Array[Symbol | String]",
-      mod, :private, [:foo, "bar"]
-    )
-  end
-
-  def test_private_class_method
-    mod = Module.new do
-      def self.foo; end
-      def self.bar; end
+    assert_visibility :private,
+                      mod, visibility
+    # No arguments
+    assert_send_type  '() -> nil',
+                      mod, visibility
+
+    # Single argument
+    assert_send_type  '(Symbol) -> Symbol',
+                      mod, visibility, :foo
+
+    with_string 'foo' do |foo|
+      assert_send_type  '[T < _ToStr] (T) -> T',
+                        mod, visibility, foo
     end
 
-    assert_send_type(
-      "(Symbol) -> Module",
-      mod, :private_class_method, :foo
-    )
+    with_interned 'foo' do |foo|
+      assert_send_type  '(interned) -> interned',
+                        mod, visibility, foo
+    end
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Module",
-      mod, :private_class_method, :foo, :bar
-    )
+    # Multiple arguments
+    assert_send_type  '(Symbol, *Symbol) -> Array[Symbol]',
+                      mod, visibility, :foo, :bar
 
-    assert_send_type(
-      "(String) -> Module",
-      mod, :private_class_method, "foo"
-    )
+    with_string 'foo' do |foo|
+      with_string 'bar' do |bar|
+        assert_send_type  '[T < _ToStr] (T, *T) -> Array[T]',
+                          mod, visibility, foo, bar
+      end
+    end
 
-    assert_send_type(
-      "(String, String) -> Module",
-      mod, :private_class_method, "foo", "bar"
-    )
+    with_interned 'foo' do |foo|
+      with_interned 'bar' do |bar|
+        assert_send_type  '(interned, *interned) -> Array[interned]',
+                          mod, visibility, foo, bar
+      end
+    end
 
-    assert_send_type(
-      "(Array[Symbol | String]) -> Module",
-      mod, :private_class_method, [:foo, "bar"]
-    )
+    # With the array version
+    assert_send_type  '(Array[String]) -> Array[String]',
+                      mod, visibility, [:foo]
+    with_string 'foo' do |foo|
+      assert_send_type  '[T < _ToStr] (Array[T]) -> Array[T]',
+                        mod, visibility, [foo]
+    end
+    with_interned 'foo' do |foo|
+      with_interned 'bar' do |bar|
+        assert_send_type  '(Array[interned]) -> Array[interned]',
+                          mod, visibility, [foo, bar]
+      end
+    end
   end
 
-  def test_protected
-    mod = Module.new do
-      def foo; end
 
-      def bar; end
-    end
+  def test_private
+    visibility_helper(:private)
+  end
 
-    assert_send_type(
-      "() -> nil",
-      mod, :protected
-    )
-    assert_send_type(
-      "(Symbol) -> Symbol",
-      mod, :protected, :foo
-    )
-    assert_send_type(
-      "(String) -> String",
-      mod, :protected, "foo"
-    )
-    assert_send_type(
-      "(ToStr) -> ToStr",
-      mod, :protected, ToStr.new("foo")
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol | String]",
-      mod, :protected, :foo, "bar"
-    )
-
-    assert_send_type(
-      "(Array[Symbol | String]) -> Array[Symbol | String]",
-      mod, :protected, [:foo, "bar"]
-    )
+  def test_protected
+    visibility_helper(:protected)
   end
 
   def test_public
-    mod = Module.new do
-      def foo; end
+    visibility_helper(:public)
+  end
 
-      def bar; end
+
+  def test_private_class_method
+    mod = Module.new do
+      def self.foo; end
+      def self.bar; end
     end
 
-    assert_send_type(
-      "() -> nil",
-      mod, :public
-    )
-    assert_send_type(
-      "(Symbol) -> Symbol",
-      mod, :public, :foo
-    )
-    assert_send_type(
-      "(String) -> String",
-      mod, :public, "foo"
-    )
-    assert_send_type(
-      "(ToStr) -> ToStr",
-      mod, :public, ToStr.new("foo")
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[interned]",
-      mod, :public, :foo, "bar"
-    )
-
-    assert_send_type(
-      "(Array[Symbol | String]) -> Array[Symbol | String]",
-      mod, :public, [:foo, "bar"]
-    )
+    assert_send_type  '() -> Module',
+                      mod, :private_class_method
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Module',
+                        mod, :private_class_method, foo
+      assert_send_type  '(Array[interned]) -> Module',
+                        mod, :private_class_method, [foo]
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, *interned) -> Module',
+                          mod, :private_class_method, foo, bar
+        assert_send_type  '(Array[interned]) -> Module',
+                          mod, :private_class_method, [foo, bar]
+      end
+    end
   end
-
   def test_public_class_method
     mod = Module.new do
       def self.foo; end
       def self.bar; end
     end
 
-    assert_send_type(
-      "(Symbol) -> Module",
-      mod, :public_class_method, :foo
-    )
+    assert_send_type  '() -> Module',
+                      mod, :public_class_method
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Module',
+                        mod, :public_class_method, foo
+      assert_send_type  '(Array[interned]) -> Module',
+                        mod, :public_class_method, [foo]
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, *interned) -> Module',
+                          mod, :public_class_method, foo, bar
+        assert_send_type  '(Array[interned]) -> Module',
+                          mod, :public_class_method, [foo, bar]
+      end
+    end
+  end
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Module",
-      mod, :public_class_method, :foo, :bar
-    )
+  def test_attr
+    mod = Module.new
 
-    assert_send_type(
-      "(String) -> Module",
-      mod, :public_class_method, "foo"
-    )
+    assert_send_type  '() -> Array[Symbol]',
+                       mod, :attr
 
-    assert_send_type(
-      "(String, String) -> Module",
-      mod, :public_class_method, "foo", "bar"
-    )
+    with_interned :foo do |foo|
+      with_bool do |writer|
+        assert_send_type  '(interned, bool) -> Array[Symbol]',
+                          mod, :attr, foo, writer
+      end
 
-    assert_send_type(
-      "(Array[Symbol | String]) -> Module",
-      mod, :public_class_method, [:foo, "bar"]
-    )
-  end
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        mod, :attr, foo
 
-  def test_attr
-    mod = Module.new
-    assert_send_type(
-      "(*interned arg0) -> Array[Symbol]",
-      mod, :attr, :foo
-    )
+      with_interned :bar do |bar|
+        assert_send_type  '(*interned) -> Array[Symbol]',
+                          mod, :attr, foo, bar
+      end
+    end
   end
 
   def test_attr_reader
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_reader, :foo
-    )
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :attr_reader
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_reader, :foo, :bar
-    )
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        mod, :attr_reader, foo
 
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_reader, "foo"
-    )
-
-    assert_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_reader, "foo", "bar"
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_reader, :foo, "bar"
-    )
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          mod, :attr_reader, foo, bar
+      end
+    end
   end
 
   def test_attr_writer
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_writer, :foo
-    )
-
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_writer, :foo, :bar
-    )
-
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_writer, "foo"
-    )
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :attr_writer
 
-    assert_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_writer, "foo", "bar"
-    )
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        mod, :attr_writer, foo
 
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_writer, :foo, "bar"
-    )
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          mod, :attr_writer, foo, bar
+      end
+    end
   end
 
   def test_attr_accessor
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_accessor, :foo
-    )
-
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_accessor, :foo, :bar
-    )
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :attr_accessor
 
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_accessor, "foo"
-    )
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        mod, :attr_accessor, foo
 
-    assert_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_accessor, "foo", "bar"
-    )
-
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_accessor, :foo, "bar"
-    )
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          mod, :attr_accessor, foo, bar
+      end
+    end
   end
 
   def test_ruby2_keywords
-    assert_send_type(
-      "(Symbol) -> nil",
-      Foo, :ruby2_keywords, :foo
-    )
+    mod = Module.new do
+      def a(*x) = 3
+      def b(*x) = 3
+    end
+
+    assert_visibility :private,
+                      mod, :ruby2_keywords
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> nil',
+                        mod, :ruby2_keywords, foo
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, *interned) -> nil',
+                          mod, :ruby2_keywords, foo, bar
+      end
+    end
   end
 
   def test_set_temporary_name
     mod = Module.new
 
+    assert_send_type '(nil) -> Module',
+                     mod, :set_temporary_name, nil
+
     with_string "fake_name" do |name|
-      assert_send_type(
-        "(::string) -> ::Module",
-        mod, :set_temporary_name, name
-      )
+      assert_send_type '(string) -> Module',
+                       mod, :set_temporary_name, name
     end
-
-    assert_send_type(
-      "(nil) -> Module",
-      mod, :set_temporary_name, nil
-    )
   end
 
   def test_to_s(method: :to_s)
@@ -619,10 +578,6 @@ def test_method_defined
     omit 'todo'
   end
 
-  def test_module_exec
-    omit 'todo'
-  end
-
   def test_name
     omit 'todo'
   end

From 0fa137bff184be5eece8799d681f1463a2056ca7 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Thu, 26 Mar 2026 15:46:24 -0700
Subject: [PATCH 05/11] more methods updated, but tehre are some problems with
 warnings

---
 core/module.rbs            |  27 +--
 test/stdlib/Module_test.rb | 348 +++++++++++++++++++++++++++++++++----
 2 files changed, 330 insertions(+), 45 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 321389aa5..34566656f 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -272,7 +272,7 @@ class Module
   #     Math.ancestors       #=> [Math]
   #     Enumerable.ancestors #=> [Enumerable]
   #
-  def ancestors: () -> ::Array[Module]
+  def ancestors: () -> Array[Module]
 
   # <!--
   #   rdoc-file=eval.c
@@ -431,7 +431,7 @@ class Module
   #     Fred.class_variable_defined?(:@@foo)    #=> true
   #     Fred.class_variable_defined?(:@@bar)    #=> false
   #
-  def class_variable_defined?: (interned arg0) -> bool
+  def class_variable_defined?: (interned name) -> bool
 
   # <!--
   #   rdoc-file=object.c
@@ -447,7 +447,7 @@ class Module
   #     end
   #     Fred.class_variable_get(:@@foo)     #=> 99
   #
-  def class_variable_get: (interned arg0) -> untyped
+  def class_variable_get: (interned name) -> untyped
 
   # <!--
   #   rdoc-file=object.c
@@ -466,7 +466,7 @@ class Module
   #     Fred.class_variable_set(:@@foo, 101)     #=> 101
   #     Fred.new.foo                             #=> 101
   #
-  def class_variable_set: (interned arg0, untyped arg1) -> untyped
+  def class_variable_set: [T] (interned name, T value) -> T
 
   # <!--
   #   rdoc-file=object.c
@@ -486,7 +486,7 @@ class Module
   #     Two.class_variables          #=> [:@@var2, :@@var1]
   #     Two.class_variables(false)   #=> [:@@var2]
   #
-  def class_variables: (?boolish inherit) -> ::Array[Symbol]
+  def class_variables: (?boolish inherit) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=object.c
@@ -649,7 +649,7 @@ class Module
   #       const_get(name, false)
   #     end
   #
-  def const_missing: (Symbol arg0) -> untyped
+  def const_missing: (Symbol name) -> untyped
 
   # <!--
   #   rdoc-file=object.c
@@ -667,7 +667,7 @@ class Module
   #
   #     Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar
   #
-  def const_set: (interned arg0, untyped arg1) -> untyped
+  def const_set: [T] (interned name, T value) -> T
 
   # <!--
   #   rdoc-file=object.c
@@ -795,7 +795,8 @@ class Module
   #     HTTP::NOT_FOUND
   #     # warning: constant HTTP::NOT_FOUND is deprecated
   #
-  def deprecate_constant: (*interned) -> self
+  def deprecate_constant: () -> self
+                        | (interned name, *interned more_names) -> self
 
   def equal?: (untyped other) -> bool
 
@@ -924,7 +925,7 @@ class Module
   #     Mixin.included_modules   #=> [Sub]
   #     Outer.included_modules   #=> [Sub, Mixin]
   #
-  def included_modules: () -> ::Array[Module]
+  def included_modules: () -> Array[Module]
 
   # <!--
   #   rdoc-file=object.c
@@ -983,7 +984,7 @@ class Module
   #
   #     Hello there, Dave!
   #
-  def instance_method: (interned arg0) -> UnboundMethod
+  def instance_method: (interned name) -> UnboundMethod
 
   # <!--
   #   rdoc-file=object.c
@@ -1338,7 +1339,8 @@ class Module
   # -->
   # Makes a list of existing constants private.
   #
-  def private_constant: (*interned arg0) -> self
+  def private_constant: () -> self
+                      | (interned name, *interned more_names) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1538,7 +1540,8 @@ class Module
   # -->
   # Makes a list of existing constants public.
   #
-  def public_constant: (*interned arg0) -> self
+  def public_constant: () -> self
+                     | (interned name, *interned more_names) -> self
 
   # <!--
   #   rdoc-file=proc.c
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index ba29dfbbb..77b73908f 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -267,10 +267,9 @@ def foo
   end
 
   # Helper for `private`, `public`, and `protected`, as they all function identically
-  def visibility_helper(visibility)
+  def classlevel_visibility_helper(visibility)
     mod = Module.new do
       def foo; end
-
       def bar; end
     end
 
@@ -329,15 +328,15 @@ def bar; end
 
 
   def test_private
-    visibility_helper(:private)
+    classlevel_visibility_helper(:private)
   end
 
   def test_protected
-    visibility_helper(:protected)
+    classlevel_visibility_helper(:protected)
   end
 
   def test_public
-    visibility_helper(:public)
+    classlevel_visibility_helper(:public)
   end
 
 
@@ -491,47 +490,132 @@ def test_set_temporary_name
   end
 
   def test_to_s(method: :to_s)
-    omit 'todo'
+    assert_send_type  '() -> String',
+                      Module.new, method
   end
 
   def test_inspect
-    test_to_s(method: :inspcet)
+    test_to_s(method: :inspect)
   end
 
   def test_ancestors
-    omit 'todo'
+    assert_send_type  '() -> Array[Module]',
+                      Module.new, :ancestors
+    assert_send_type  '() -> Array[Module]',
+                      Module, :ancestors
   end
 
   def test_autoload
     omit 'todo'
   end
 
-  def test_autoload
+  def test_autoload?
     omit 'todo'
   end
 
-  def test_class_variable_defined
-    omit 'todo'
+  def test_class_variable_defined?
+    mod = Module.new
+
+    with_interned :@@module_test_class_variable_defined do |name|
+      assert_send_type "(interned) -> bool",
+                       mod, :class_variable_defined?, name
+    end
+
+    mod.class_variable_set :@@module_test_class_variable_defined, 12
+    with_interned :@@module_test_class_variable_defined do |name|
+      assert_send_type "(interned) -> bool",
+                       mod, :class_variable_defined?, name
+    end
   end
 
   def test_class_variable_get
-    omit 'todo'
+    mod = Module.new
+
+    # If it's not set it raises an exception
+    mod.class_variable_set :@@module_test_class_variable_get, 12
+
+    with_interned :@@module_test_class_variable_get do |name|
+      assert_send_type "(interned) -> untyped",
+                       mod, :class_variable_get, name
+    end
   end
 
   def test_class_variable_set
-    omit 'todo'
+    mod = Module.new
+
+    with_interned :@@module_test_class_variable_set do |name|
+      with_untyped do |value|
+        assert_send_type "[T] (interned, T) -> T",
+                         mod, :class_variable_set, name, value
+      end
+    end
   end
 
   def test_class_variables
-    omit 'todo'
+    mod = Module.new do
+      include Module.new {
+        class_variable_set :@@module_test_class_variables_1, 12
+      }
+
+      class_variable_set :@@module_test_class_variables_2, 34
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :class_variables
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :class_variables
+
+    with_boolish do |inherit|
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        Module.new, :class_variables, inherit
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        mod, :class_variables, inherit
+    end
   end
 
-  def test_const_defined
-    omit 'todo'
+  def test_const_defined?
+    mod = Module.new
+
+    # Before defining the constant
+    with_interned :ModuleTestConstDefined do |name|
+      assert_send_type '(interned) -> bool',
+                       mod, :const_defined?, name
+
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> bool',
+                         mod, :const_defined?, name, inherit
+      end
+    end
+
+    mod.const_set :ModuleTestConstDefined, 123
+
+    # After defining the constant
+    with_interned :ModuleTestConstDefined do |name|
+      assert_send_type '(interned) -> bool',
+                       mod, :const_defined?, name
+
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> bool',
+                         mod, :const_defined?, name, inherit
+      end
+    end
   end
 
   def test_const_get
-    omit 'todo'
+    mod = Module.new
+
+    # Define the constant first to avoid NameError paths
+    mod.const_set :ModuleTestConstGet, 123
+
+    with_interned :ModuleTestConstGet do |name|
+      assert_send_type '(interned) -> untyped',
+                       mod, :const_get, name
+
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> untyped',
+                         mod, :const_get, name, inherit
+      end
+    end
   end
 
   def test_const_missing
@@ -539,23 +623,60 @@ def test_const_missing
   end
 
   def test_const_set
-    omit 'todo'
+    mod = Module.new
+
+    with_interned :ModuleTestConstSet do |name|
+      with_untyped do |value|
+        assert_send_type '[T] (interned, T) -> T',
+                         mod, :const_set, name, value
+      end
+    end
   end
 
   def test_define_method
     omit 'todo'
   end
 
+  def constant_visibility_helper(method)
+    mod = Module.new do
+      const_set :Foo, 3
+      const_set :Bar, 4
+    end
+
+    # No arguments yields a warning with `-w`
+    begin
+      old_v, $-v = $-v, nil
+      assert_send_type  '() -> Module',
+                        mod, method
+    ensure
+      $-v = old_v
+    end
+
+    with_interned :Foo do |foo|
+      assert_send_type  '(interned) -> Module',
+                        mod, method, foo
+
+      with_interned :Bar do |bar|
+        assert_send_type  '(interned, *interned) -> Module',
+                          mod, method, foo, bar
+      end
+    end
+  end
+
   def test_deprecate_constant
-    omit 'todo'
+    constant_visibility_helper(:deprecate_constant)
   end
 
   def test_freeze
-    omit 'todo'
+    assert_send_type  '() -> Module',
+                      Module.new, :freeze
   end
 
   def test_included_modules
-    omit 'todo'
+    assert_send_type  '() -> Array[Module]',
+                      Module.new, :included_modules
+    assert_send_type  '() -> Array[Module]',
+                      Module.new{ include Module.new }, :included_modules
   end
 
   def test_initialize
@@ -567,43 +688,164 @@ def test_initialize_clone
   end
 
   def test_instance_method
-    omit 'todo'
+    mod = Module.new do
+      def foo = 3
+    end
+
+    with_interned :foo do |name|
+      assert_send_type '(interned) -> UnboundMethod',
+                       mod, :instance_method, name
+    end
   end
 
   def test_instance_methods
     omit 'todo'
   end
 
-  def test_method_defined
-    omit 'todo'
+  def test_method_defined?
+    mod = Module.new do
+      include Module.new { def bar = 1 }
+      def foo = 2
+    end
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> bool',
+                        mod, :method_defined?, foo
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :method_defined?, foo, inherit
+      end
+    end
+
+    with_interned :bar do |bar|
+      assert_send_type  '(interned) -> bool',
+                        mod, :method_defined?, bar
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :method_defined?, bar, inherit
+      end
+    end
+
+    with_interned :baz do |baz|
+      assert_send_type  '(interned) -> bool',
+                        mod, :method_defined?, baz
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :method_defined?, baz, inherit
+      end
+    end
   end
 
   def test_name
-    omit 'todo'
+    assert_send_type  '() -> nil',
+                      Module.new, :name
+
+    assert_send_type  '() -> String',
+                      Comparable, :name
   end
 
   def test_private_constant
-    omit 'todo'
+    constant_visibility_helper(:private_constant)
   end
 
   def test_private_instance_methods
     omit 'todo'
   end
 
-  def test_private_method_defined
-    omit 'todo'
+  def test_private_method_defined?
+    mod = Module.new do
+      include Module.new { private def bar = 1 }
+      private def foo = 2
+      public def baz = 3
+    end
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> bool',
+                        mod, :private_method_defined?, foo
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :private_method_defined?, foo, inherit
+      end
+    end
+
+    with_interned :bar do |bar|
+      assert_send_type  '(interned) -> bool',
+                        mod, :private_method_defined?, bar
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :private_method_defined?, bar, inherit
+      end
+    end
+
+    with_interned :baz do |baz|
+      assert_send_type  '(interned) -> bool',
+                        mod, :private_method_defined?, baz
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :private_method_defined?, baz, inherit
+      end
+    end
+
+    with_interned :quux do |quux|
+      assert_send_type  '(interned) -> bool',
+                        mod, :private_method_defined?, quux
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :private_method_defined?, quux, inherit
+      end
+    end
   end
 
   def test_protected_instance_methods
     omit 'todo'
   end
 
-  def test_protected_method_defined
-    omit 'todo'
+  def test_protected_method_defined?
+    mod = Module.new do
+      include Module.new { protected def bar = 1 }
+      protected def foo = 2
+      public def baz = 3
+    end
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> bool',
+                        mod, :protected_method_defined?, foo
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :protected_method_defined?, foo, inherit
+      end
+    end
+
+    with_interned :bar do |bar|
+      assert_send_type  '(interned) -> bool',
+                        mod, :protected_method_defined?, bar
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :protected_method_defined?, bar, inherit
+      end
+    end
+
+    with_interned :baz do |baz|
+      assert_send_type  '(interned) -> bool',
+                        mod, :protected_method_defined?, baz
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :protected_method_defined?, baz, inherit
+      end
+    end
+
+    with_interned :quux do |quux|
+      assert_send_type  '(interned) -> bool',
+                        mod, :protected_method_defined?, quux
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :protected_method_defined?, quux, inherit
+      end
+    end
   end
 
   def test_public_constant
-    omit 'todo'
+    constant_visibility_helper(:public_constant)
   end
 
   def test_public_instance_method
@@ -614,8 +856,48 @@ def test_public_instance_methods
     omit 'todo'
   end
 
-  def test_public_method_defined
-    omit 'todo'
+  def test_public_method_defined?
+    mod = Module.new do
+      include Module.new { public def bar = 1 }
+      public def foo = 2
+      private def baz = 3
+    end
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> bool',
+                        mod, :public_method_defined?, foo
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :public_method_defined?, foo, inherit
+      end
+    end
+
+    with_interned :bar do |bar|
+      assert_send_type  '(interned) -> bool',
+                        mod, :public_method_defined?, bar
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :public_method_defined?, bar, inherit
+      end
+    end
+
+    with_interned :baz do |baz|
+      assert_send_type  '(interned) -> bool',
+                        mod, :public_method_defined?, baz
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :public_method_defined?, baz, inherit
+      end
+    end
+
+    with_interned :quux do |quux|
+      assert_send_type  '(interned) -> bool',
+                        mod, :public_method_defined?, quux
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> bool',
+                          mod, :public_method_defined?, quux, inherit
+      end
+    end
   end
 
   def test_remove_class_variable

From bf2e8a927bb3f5a851c6cd6141b34e6fad53f960 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Thu, 26 Mar 2026 15:58:41 -0700
Subject: [PATCH 06/11] added disable_verbose to disable verbose warnings when
 testing

---
 test/stdlib/Module_test.rb | 54 +++++++++++++++-----------------------
 test/stdlib/test_helper.rb | 11 ++++++++
 2 files changed, 32 insertions(+), 33 deletions(-)

diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 77b73908f..538d978d1 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -386,74 +386,69 @@ def self.bar; end
   end
 
   def test_attr
-    mod = Module.new
-
     assert_send_type  '() -> Array[Symbol]',
-                       mod, :attr
+                       Module.new, :attr
 
     with_interned :foo do |foo|
       with_bool do |writer|
-        assert_send_type  '(interned, bool) -> Array[Symbol]',
-                          mod, :attr, foo, writer
+        # attr with bool arguments yields a warning normally
+        disable_verbose do
+          assert_send_type  '(interned, bool) -> Array[Symbol]',
+                            Module.new, :attr, foo, writer
+        end
       end
 
       assert_send_type  '(interned) -> Array[Symbol]',
-                        mod, :attr, foo
+                        Module.new, :attr, foo
 
       with_interned :bar do |bar|
         assert_send_type  '(*interned) -> Array[Symbol]',
-                          mod, :attr, foo, bar
+                          Module.new, :attr, foo, bar
       end
     end
   end
 
   def test_attr_reader
-    mod = Module.new
-
     assert_send_type  '() -> Array[Symbol]',
-                      mod, :attr_reader
+                      Module.new, :attr_reader
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> Array[Symbol]',
-                        mod, :attr_reader, foo
+                        Module.new, :attr_reader, foo
 
       with_interned :bar do |bar|
         assert_send_type  '(interned, interned) -> Array[Symbol]',
-                          mod, :attr_reader, foo, bar
+                          Module.new, :attr_reader, foo, bar
       end
     end
   end
 
   def test_attr_writer
-    mod = Module.new
-
     assert_send_type  '() -> Array[Symbol]',
-                      mod, :attr_writer
+                      Module.new, :attr_writer
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> Array[Symbol]',
-                        mod, :attr_writer, foo
+                        Module.new, :attr_writer, foo
 
       with_interned :bar do |bar|
         assert_send_type  '(interned, interned) -> Array[Symbol]',
-                          mod, :attr_writer, foo, bar
+                          Module.new, :attr_writer, foo, bar
       end
     end
   end
 
   def test_attr_accessor
-    mod = Module.new
-
     assert_send_type  '() -> Array[Symbol]',
-                      mod, :attr_accessor
+                      Module.new, :attr_accessor
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> Array[Symbol]',
-                        mod, :attr_accessor, foo
+                        Module.new, :attr_accessor, foo
 
       with_interned :bar do |bar|
         assert_send_type  '(interned, interned) -> Array[Symbol]',
-                          mod, :attr_accessor, foo, bar
+                          Module.new, :attr_accessor, foo, bar
       end
     end
   end
@@ -478,14 +473,12 @@ def b(*x) = 3
   end
 
   def test_set_temporary_name
-    mod = Module.new
-
     assert_send_type '(nil) -> Module',
-                     mod, :set_temporary_name, nil
+                     Module.new, :set_temporary_name, nil
 
     with_string "fake_name" do |name|
       assert_send_type '(string) -> Module',
-                       mod, :set_temporary_name, name
+                       Module.new, :set_temporary_name, name
     end
   end
 
@@ -623,12 +616,10 @@ def test_const_missing
   end
 
   def test_const_set
-    mod = Module.new
-
     with_interned :ModuleTestConstSet do |name|
       with_untyped do |value|
         assert_send_type '[T] (interned, T) -> T',
-                         mod, :const_set, name, value
+                         Module.new, :const_set, name, value
       end
     end
   end
@@ -644,12 +635,9 @@ def constant_visibility_helper(method)
     end
 
     # No arguments yields a warning with `-w`
-    begin
-      old_v, $-v = $-v, nil
+    disable_verbose do
       assert_send_type  '() -> Module',
                         mod, method
-    ensure
-      $-v = old_v
     end
 
     with_interned :Foo do |foo|
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index beea49803..7fa0eb0ab 100644
--- a/test/stdlib/test_helper.rb
+++ b/test/stdlib/test_helper.rb
@@ -148,6 +148,17 @@ def self.included(base)
     base.extend RBS::UnitTest::TypeAssertions::ClassMethods
   end
 
+  # Disables verbose mode for the duration of the passed block. Used when
+  # testing codepaths which emit warnings when run.
+  #
+  # The `verbose` variable can be used to change the verbosity if needed.
+  def disable_verbose(verbose = nil)
+    old_verbose, $VERBOSE = $VERBOSE, verbose
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
   RUBY_EXECUTABLE = ENV["RUBY"] || RbConfig.ruby
 end
 

From 34f9a7662d18759f77d03263e006d30b9d3bc88a Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Thu, 26 Mar 2026 16:34:34 -0700
Subject: [PATCH 07/11] good progress

---
 core/module.rbs            |   6 +-
 test/stdlib/Module_test.rb | 156 ++++++++++++++++++++++++++++++++-----
 2 files changed, 140 insertions(+), 22 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 34566656f..256174c53 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -1558,7 +1558,7 @@ class Module
   # Returns a list of the public instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def public_instance_methods: (?boolish include_super) -> ::Array[Symbol]
+  def public_instance_methods: (?boolish include_super) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1640,7 +1640,7 @@ class Module
   #     99
   #     nil
   #
-  def remove_class_variable: (interned arg0) -> untyped
+  def remove_class_variable: (interned name) -> untyped
 
   # <!--
   #   rdoc-file=object.c
@@ -1660,7 +1660,7 @@ class Module
   # Removes the method identified by *symbol* from the current class. For an
   # example, see Module#undef_method. String arguments are converted to symbols.
   #
-  def remove_method: (*interned arg0) -> self
+  def remove_method: (*interned method_names) -> self
 
   # <!--
   #   rdoc-file=vm_method.c
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 538d978d1..3b945a6b9 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -509,15 +509,15 @@ def test_autoload?
   def test_class_variable_defined?
     mod = Module.new
 
-    with_interned :@@module_test_class_variable_defined do |name|
+    with_interned :@@module_test_class_variable_defined do |cvar|
       assert_send_type "(interned) -> bool",
-                       mod, :class_variable_defined?, name
+                       mod, :class_variable_defined?, cvar
     end
 
     mod.class_variable_set :@@module_test_class_variable_defined, 12
-    with_interned :@@module_test_class_variable_defined do |name|
+    with_interned :@@module_test_class_variable_defined do |cvar|
       assert_send_type "(interned) -> bool",
-                       mod, :class_variable_defined?, name
+                       mod, :class_variable_defined?, cvar
     end
   end
 
@@ -527,19 +527,19 @@ def test_class_variable_get
     # If it's not set it raises an exception
     mod.class_variable_set :@@module_test_class_variable_get, 12
 
-    with_interned :@@module_test_class_variable_get do |name|
+    with_interned :@@module_test_class_variable_get do |cvar|
       assert_send_type "(interned) -> untyped",
-                       mod, :class_variable_get, name
+                       mod, :class_variable_get, cvar
     end
   end
 
   def test_class_variable_set
     mod = Module.new
 
-    with_interned :@@module_test_class_variable_set do |name|
+    with_interned :@@module_test_class_variable_set do |cvar|
       with_untyped do |value|
         assert_send_type "[T] (interned, T) -> T",
-                         mod, :class_variable_set, name, value
+                         mod, :class_variable_set, cvar, value
       end
     end
   end
@@ -678,16 +678,41 @@ def test_initialize_clone
   def test_instance_method
     mod = Module.new do
       def foo = 3
+      private def bar = 4
     end
 
     with_interned :foo do |name|
       assert_send_type '(interned) -> UnboundMethod',
                        mod, :instance_method, name
     end
+
+    with_interned :bar do |name|
+      assert_send_type '(interned) -> UnboundMethod',
+                       mod, :instance_method, name
+    end
   end
 
   def test_instance_methods
-    omit 'todo'
+    mod = Module.new do
+      include Module.new {
+        public def foo1 = 1
+        private def foo2 = 1
+        protected def foo3 = 1
+      }
+      public def bar1 = 1
+      private def bar2 = 1
+      protected def bar3 = 1
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :instance_methods
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :instance_methods
+
+    with_boolish do |include_super|
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        mod, :instance_methods, include_super
+    end
   end
 
   def test_method_defined?
@@ -737,7 +762,23 @@ def test_private_constant
   end
 
   def test_private_instance_methods
-    omit 'todo'
+    mod = Module.new do
+      include Module.new {
+        private def bar = 4
+      }
+
+      private def foo = 3
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :private_instance_methods
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :private_instance_methods
+
+    with_boolish do |include_super|
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        mod, :private_instance_methods, include_super
+    end
   end
 
   def test_private_method_defined?
@@ -785,7 +826,23 @@ def test_private_method_defined?
   end
 
   def test_protected_instance_methods
-    omit 'todo'
+    mod = Module.new do
+      include Module.new {
+        protected def bar = 4
+      }
+
+      protected def foo = 3
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :protected_instance_methods
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :protected_instance_methods
+
+    with_boolish do |include_super|
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        mod, :protected_instance_methods, include_super
+    end
   end
 
   def test_protected_method_defined?
@@ -837,11 +894,34 @@ def test_public_constant
   end
 
   def test_public_instance_method
-    omit 'todo'
+    mod = Module.new do
+      def foo = 3
+    end
+
+    with_interned :foo do |name|
+      assert_send_type '(interned) -> UnboundMethod',
+                       mod, :instance_method, name
+    end
   end
 
   def test_public_instance_methods
-    omit 'todo'
+    mod = Module.new do
+      include Module.new {
+        def bar = 4
+      }
+
+      def foo = 3
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :public_instance_methods
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :public_instance_methods
+
+    with_boolish do |include_super|
+      assert_send_type  '(boolish) -> Array[Symbol]',
+                        mod, :public_instance_methods, include_super
+    end
   end
 
   def test_public_method_defined?
@@ -889,23 +969,61 @@ def test_public_method_defined?
   end
 
   def test_remove_class_variable
-    omit 'todo'
+    with_interned :@@module_test_remove_class_variable do |cvar|
+      mod = Module.new do
+        class_variable_set(:@@module_test_remove_class_variable, 123)
+      end
+
+      assert_send_type  '(interned) -> untyped',
+                        mod, :remove_class_variable, cvar
+    end
   end
 
   def test_remove_method
-    omit 'todo'
+    assert_send_type  '() -> Module',
+                      Module.new, :remove_method
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Module',
+                        Module.new { def foo = 3 }, :remove_method, foo
+      with_interned :bar do |bar|
+        assert_send_type  '(*interned) -> Module',
+                          Module.new { def foo = 3; def bar = 4 }, :remove_method, foo, bar
+      end
+    end
   end
 
-  def test_singleton_class
-    omit 'todo'
+  def test_singleton_class?
+    assert_send_type  '() -> bool',
+                      Module, :singleton_class?
+    assert_send_type  '() -> bool',
+                      Module.singleton_class, :singleton_class?
   end
 
   def test_undef_method
-    omit 'todo'
+    assert_send_type  '() -> Module',
+                      Module.new, :undef_method
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Module',
+                        Module.new { def foo = 3 }, :undef_method, foo
+      with_interned :bar do |bar|
+        assert_send_type  '(*interned) -> Module',
+                          Module.new { def foo = 3; def bar = 4 }, :undef_method, foo, bar
+      end
+    end
   end
 
   def test_undefined_instance_methods
-    omit 'todo'
+    mod = Module.new do
+      def foo = 4
+      undef foo
+    end
+
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :undefined_instance_methods
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :undefined_instance_methods
   end
 
   def test_append_features

From 39e6a65c0a9398cf1265fc5155bf4505abf41597 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Fri, 27 Mar 2026 23:00:44 -0700
Subject: [PATCH 08/11] gotta now fix assert visibility

---
 core/module.rbs                      |  24 +++---
 lib/rbs/unit_test/type_assertions.rb |   2 +-
 test/stdlib/Module_test.rb           | 112 +++++++++++++++++++++------
 3 files changed, 101 insertions(+), 37 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 256174c53..b22c626b4 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -735,7 +735,7 @@ class Module
   #
   # Also see Module#const_defined?.
   #
-  def constants: (?boolish inherit) -> ::Array[Symbol]
+  def constants: (?boolish inherit) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=proc.c
@@ -795,8 +795,7 @@ class Module
   #     HTTP::NOT_FOUND
   #     # warning: constant HTTP::NOT_FOUND is deprecated
   #
-  def deprecate_constant: () -> self
-                        | (interned name, *interned more_names) -> self
+  def deprecate_constant: (*interned names) -> self
 
   def equal?: (untyped other) -> bool
 
@@ -830,7 +829,7 @@ class Module
 
   # <!--
   #   rdoc-file=object.c
-  #   - extended(othermod)
+  #   -   (othermod)
   # -->
   # The equivalent of `included`, but for extended modules.
   #
@@ -952,8 +951,9 @@ class Module
   # Assign the module to a constant (name starting uppercase) if you want to treat
   # it like a regular module.
   #
-  def initialize: () -> void
-                | () { (Module arg0) -> untyped } -> void
+  def initialize: () ?{ (Module mod) [self: self] -> void } -> void
+
+  def initialize_clone: (Module source, ?freeze: bool?) -> void
 
   # <!--
   #   rdoc-file=proc.c
@@ -1021,7 +1021,7 @@ class Module
   #     end
   #     C.instance_methods(false).sort               #=> [:method2, :method3, :method4]
   #
-  def instance_methods: (?boolish include_super) -> ::Array[Symbol]
+  def instance_methods: (?boolish include_super) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=object.c
@@ -1339,8 +1339,7 @@ class Module
   # -->
   # Makes a list of existing constants private.
   #
-  def private_constant: () -> self
-                      | (interned name, *interned more_names) -> self
+  def private_constant: (*interned names) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1357,7 +1356,7 @@ class Module
   #     Mod.instance_methods           #=> [:method2]
   #     Mod.private_instance_methods   #=> [:method1]
   #
-  def private_instance_methods: (?boolish include_super) -> ::Array[Symbol]
+  def private_instance_methods: (?boolish include_super) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1463,7 +1462,7 @@ class Module
   # Returns a list of the protected instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def protected_instance_methods: (?boolish include_super) -> ::Array[Symbol]
+  def protected_instance_methods: (?boolish include_super) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1540,8 +1539,7 @@ class Module
   # -->
   # Makes a list of existing constants public.
   #
-  def public_constant: () -> self
-                     | (interned name, *interned more_names) -> self
+  def public_constant: (*interned names) -> self
 
   # <!--
   #   rdoc-file=proc.c
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index 632b97487..2fdb3856b 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -297,7 +297,7 @@ def assert_const_type(type, constant_name)
       end
 
       def assert_visibility(vis, receiver, method)
-        omit 'TODO: visibility for types'
+        puts 'TODO: visibility for types'
       end
 
       def assert_type(type, value)
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 3b945a6b9..01892d6a5 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -312,7 +312,7 @@ def bar; end
     end
 
     # With the array version
-    assert_send_type  '(Array[String]) -> Array[String]',
+    assert_send_type  '(Array[Symbol]) -> Array[Symbol]',
                       mod, visibility, [:foo]
     with_string 'foo' do |foo|
       assert_send_type  '[T < _ToStr] (Array[T]) -> Array[T]',
@@ -346,8 +346,10 @@ def self.foo; end
       def self.bar; end
     end
 
-    assert_send_type  '() -> Module',
-                      mod, :private_class_method
+    disable_verbose do
+      assert_send_type  '() -> Module',
+                        mod, :private_class_method
+    end
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> Module',
@@ -368,8 +370,10 @@ def self.foo; end
       def self.bar; end
     end
 
-    assert_send_type  '() -> Module',
-                      mod, :public_class_method
+    disable_verbose do
+      assert_send_type  '() -> Module',
+                        mod, :public_class_method
+    end
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> Module',
@@ -455,8 +459,8 @@ def test_attr_accessor
 
   def test_ruby2_keywords
     mod = Module.new do
-      def a(*x) = 3
-      def b(*x) = 3
+      def foo(*x) = 3
+      def bar(*x) = 3
     end
 
     assert_visibility :private,
@@ -612,7 +616,22 @@ def test_const_get
   end
 
   def test_const_missing
-    omit 'todo'
+    assert_type_meth = method(:assert_type)
+    mod = Module.new do
+      define_singleton_method :const_missing do |name|
+        assert_type_meth.call('Symbol', name)
+        1r
+      end
+    end
+
+    assert_type 'Rational',
+                mod::Foo # Test the `::` syntax works
+
+    # Make sure that `const_get` also always passes a symbol
+    with_interned :Foo do |name|
+      assert_send_type  '(interned) -> Rational',
+                        mod, :const_get, name
+    end
   end
 
   def test_const_set
@@ -625,7 +644,19 @@ def test_const_set
   end
 
   def test_define_method
-    omit 'todo'
+    with_interned :meth do |name|
+      assert_send_type  '(interned, ^(?) [self: top] -> untyped) -> Symbol',
+                        Module.new, :define_method, name, proc {}
+
+      assert_send_type  '(interned, Method) -> Symbol',
+                        Module.new, :define_method, name, method(:puts)
+
+      assert_send_type  '(interned, UnboundMethod) -> Symbol',
+                        Module.new, :define_method, name, method(:puts).unbind
+
+      assert_send_type  '(interned) { (?) [self: top] -> untyped } -> Symbol',
+                        Module.new, :define_method, name do end
+    end
   end
 
   def constant_visibility_helper(method)
@@ -668,11 +699,22 @@ def test_included_modules
   end
 
   def test_initialize
-    omit 'todo'
+    assert_send_type  '() -> void',
+                      Module.new, :initialize
+
+    assert_send_type  '() { (Module) [self: Module] -> void } -> void',
+                      Module.new, :initialize do end
   end
 
   def test_initialize_clone
-    omit 'todo'
+    assert_send_type  '(Module) -> void',
+                      Module.new, :initialize_clone, Module.new
+
+
+    with_bool.and_nil do |freeze|
+      assert_send_type  '(Module, freeze: bool?) -> void',
+                        Module.new, :initialize_clone, Module.new, freeze: freeze
+    end
   end
 
   def test_instance_method
@@ -1027,50 +1069,74 @@ def foo = 4
   end
 
   def test_append_features
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :append_features
+    omit 'todo'
   end
 
   def test_const_added
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :const_added
+    omit 'todo'
   end
 
   def test_extend_object
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :extend_object
+    omit 'todo'
   end
 
   def test_extended
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :extended
+    omit 'todo'
   end
 
   def test_included
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :included
+    omit 'todo'
   end
 
   def test_method_added
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :method_added
+    omit 'todo'
   end
 
   def test_method_removed
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :method_removed
+    omit 'todo'
   end
 
   def test_method_undefined
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :method_undefined
+    omit 'todo'
   end
 
   def test_prepend_features
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :prepend_features
+    omit 'todo'
   end
 
   def test_prepended
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :prepended
+    omit 'todo'
   end
 
   def test_remove_const
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :remove_const
+    omit 'todo'
   end
 
   def test_using
-    omit 'todo' # private
+    assert_visibility :private,
+                      Module.new, :using
+    omit 'todo'
   end
 end

From 86bbbe87498df0c387e69f34492b0610421273a6 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Wed, 1 Apr 2026 17:52:05 -0700
Subject: [PATCH 09/11] updates continued

---
 core/module.rbs            |  26 +++----
 test/stdlib/Module_test.rb | 151 ++++++++++++++++++++++++++++++++++---
 2 files changed, 152 insertions(+), 25 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index b22c626b4..9c6dc9c6f 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -284,7 +284,7 @@ class Module
   # module to *mod* if this module has not already been added to *mod* or one of
   # its ancestors. See also Module#include.
   #
-  private def append_features: (Module arg0) -> self
+  private def append_features: (Module mod) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -348,7 +348,7 @@ class Module
   #
   # Files that are currently being loaded must not be registered for autoload.
   #
-  def autoload: (interned _module, String filename) -> NilClass
+  def autoload: (interned constant, String filename) -> NilClass
 
   # <!--
   #   rdoc-file=load.c
@@ -531,7 +531,7 @@ class Module
   #     :const_added
   #     :inherited
   #
-  private def const_added: (Symbol) -> void
+  private def const_added: (Symbol const_name) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -825,7 +825,7 @@ class Module
   #     Picky added to Array
   #     Can't add Picky to a String
   #
-  private def extend_object: (untyped arg0) -> untyped
+  private def extend_object: [T] (T object) -> T
 
   # <!--
   #   rdoc-file=object.c
@@ -843,7 +843,7 @@ class Module
   #     end
   #      # => prints "A extended in Enumerable"
   #
-  private def extended: (Module othermod) -> untyped
+  private def extended: (untyped othermod) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -901,7 +901,7 @@ class Module
   #     end
   #      # => prints "A included in Enumerable"
   #
-  private def included: (Module othermod) -> untyped
+  private def included: (Module othermod) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -1041,7 +1041,7 @@ class Module
   #
   #     Adding :some_instance_method
   #
-  private def method_added: (Symbol meth) -> untyped
+  private def method_added: (Symbol method_name) -> void
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1102,7 +1102,7 @@ class Module
   #
   #     Removing :some_instance_method
   #
-  private def method_removed: (Symbol method_name) -> untyped
+  private def method_removed: (Symbol method_name) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -1127,7 +1127,7 @@ class Module
   #
   #     Undefining :some_instance_method
   #
-  private def method_undefined: (Symbol method_name) -> untyped
+  private def method_undefined: (Symbol method_name) -> void
 
   # <!--
   #   rdoc-file=vm_eval.c
@@ -1254,7 +1254,7 @@ class Module
   # this module to *mod* if this module has not already been added to *mod* or one
   # of its ancestors. See also Module#prepend.
   #
-  private def prepend_features: (Module arg0) -> self
+  private def prepend_features: (Module mod) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1272,7 +1272,7 @@ class Module
   #     end
   #      # => prints "A prepended to Enumerable"
   #
-  private def prepended: (Module othermod) -> untyped
+  private def prepended: (Module othermod) -> void
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1648,7 +1648,7 @@ class Module
   # previous value.  If that constant referred to a module, this will not change
   # that module's name and can lead to confusion.
   #
-  private def remove_const: (interned arg0) -> untyped
+  private def remove_const: (interned name) -> untyped
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1828,7 +1828,7 @@ class Module
   # Import class refinements from *module* into the current class or module
   # definition.
   #
-  private def using: (Module arg0) -> self
+  private def using: (Module mod) -> self
 
   # <!-- rdoc-file=object.c -->
   # Returns a string representing this module or class. For basic classes and
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 01892d6a5..99af2bac3 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -55,6 +55,14 @@ module RefinedModule
     end
   end
 
+  def with_untyped_singleton_possible
+    with_untyped do |untyped|
+      next if Integer === untyped || Float === untyped || Symbol === untyped
+      untyped = ::Kernel.instance_method(:dup).bind_call(untyped) if ::Kernel.instance_method(:frozen?).bind_call(untyped)
+      yield untyped
+    end
+  end
+
   def test_op_lt
     with Object, Float, Hash do |mod|
       assert_send_type  '(Module) -> bool?',
@@ -1071,72 +1079,191 @@ def foo = 4
   def test_append_features
     assert_visibility :private,
                       Module.new, :append_features
-    omit 'todo'
+
+    assert_send_type  '(Module) -> Module',
+                      Module.new, :append_features, Module.new
   end
 
   def test_const_added
     assert_visibility :private,
                       Module.new, :const_added
-    omit 'todo'
+
+    # const_added directly works
+    assert_send_type  '(Symbol) -> void',
+                      Module.new, :const_added, :foo
+
+    # Setting the constant also works
+    const_added_module = proc do
+      assert_type_meth = method(:assert_type)
+      mod = Module.new do
+        define_singleton_method :const_added do |name|
+          assert_type_meth.call('Symbol', name)
+        end
+      end
+    end
+
+    # Make sure the `::` assignment passes a symbol
+    eval <<~EOS
+      const_added_module.call()::Foo = 3
+    EOS
+
+    # Make sure that `const_set` also always passes a symbol to the `const_added`
+    with_interned :Foo do |name|
+        const_added_module.call().const_set(name, 2r)
+    end
   end
 
   def test_extend_object
     assert_visibility :private,
                       Module.new, :extend_object
-    omit 'todo'
+
+    with_untyped_singleton_possible do |untyped|
+      assert_send_type  '[T] (T) -> T',
+                        Module.new, :extend_object, untyped
+    end
+
+    # No need to make sure `object.extend(module)` works because the signature
+    # is `(T) -> T`, which means it can take any type (and we aren't testing the
+    # return value of `extend`)
   end
 
   def test_extended
     assert_visibility :private,
                       Module.new, :extended
-    omit 'todo'
+
+    with_untyped_singleton_possible do |untyped|
+      assert_send_type  '(untyped) -> void',
+                        Module.new, :extended, untyped
+    end
+
+    # No need to make sure `object.extend(module)` works because the signature
+    # is `(untyped) -> void`, which means it can take any type, and we dont care
+    # about the return value.
   end
 
   def test_included
     assert_visibility :private,
                       Module.new, :included
-    omit 'todo'
+
+    assert_send_type  '(Module) -> void',
+                      Module.new, :included, Module.new
+
+    assert_send_type  '(Module) -> void',
+                      Module.new, :included, Class.new
   end
 
   def test_method_added
     assert_visibility :private,
                       Module.new, :method_added
-    omit 'todo'
+
+
+    # method_added directly works
+    assert_send_type  '(Symbol) -> void',
+                      Module.new, :method_added, :foo
+
+    # make sure using `with_intern` always passes a symbol
+    assert_type_meth = method(:assert_type)
+    mod = Module.new do
+      define_singleton_method :method_added do |name|
+        assert_type_meth.call('Symbol', name)
+      end
+    end
+
+    with_interned :foo do |name|
+      mod.define_method(:foo) {}
+      mod.undef_method(:foo) # avoid warnings
+    end
   end
 
   def test_method_removed
     assert_visibility :private,
                       Module.new, :method_removed
-    omit 'todo'
+
+    # method_removed directly works
+    assert_send_type  '(Symbol) -> void',
+                      Module.new, :method_removed, :foo
+
+    # make sure using `with_intern` always passes a symbol
+    assert_type_meth = method(:assert_type)
+    mod = Module.new do
+      define_singleton_method :method_removed do |name|
+        assert_type_meth.call('Symbol', name)
+      end
+    end
+
+    with_interned :foo do |name|
+      mod.define_method(:foo) {}
+      mod.remove_method(name)
+    end
   end
 
   def test_method_undefined
     assert_visibility :private,
                       Module.new, :method_undefined
-    omit 'todo'
+
+    # method_undefined directly works
+    assert_send_type  '(Symbol) -> void',
+                      Module.new, :method_undefined, :foo
+
+    # make sure using `with_intern` always passes a symbol
+    assert_type_meth = method(:assert_type)
+    mod = Module.new do
+      define_singleton_method :method_undefined do |name|
+        assert_type_meth.call('Symbol', name)
+      end
+    end
+
+    with_interned :foo do |name|
+      mod.define_method(:foo) {}
+      mod.undef_method(name)
+    end
   end
 
   def test_prepend_features
     assert_visibility :private,
                       Module.new, :prepend_features
-    omit 'todo'
+
+    assert_send_type  '(Module) -> Module',
+                      Module.new, :prepend_features, Module.new
+
+    assert_send_type  '(Module) -> Module',
+                      Module.new, :prepend_features, Class.new
   end
 
   def test_prepended
     assert_visibility :private,
                       Module.new, :prepended
-    omit 'todo'
+
+    assert_send_type  '(Module) -> void',
+                      Module.new, :prepended, Module.new
+
+    assert_send_type  '(Module) -> void',
+                      Module.new, :prepended, Class.new
   end
 
   def test_remove_const
     assert_visibility :private,
                       Module.new, :remove_const
-    omit 'todo'
+
+    with_interned :Foo do |name|
+      mod = Module.new
+      mod.const_set :Foo, 1r
+
+      assert_send_type  '(interned) -> untyped',
+                        mod, :remove_const, name
+    end
+  end
+
+
+  module UsingModule
+    UsingReturnValue = using Module.new
   end
 
   def test_using
     assert_visibility :private,
                       Module.new, :using
-    omit 'todo'
+
+    # Cant actually test `using` in modules, so this is the best we got
+    assert_type 'Module', UsingModule::UsingModule
   end
 end

From 033ef0832e2b8e1e08e42173ce0aa2d2353dc74f Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Tue, 14 Apr 2026 16:18:29 -0700
Subject: [PATCH 10/11] update module

---
 core/module.rbs                      |  4 ++--
 lib/rbs/unit_test/type_assertions.rb |  9 +++++++--
 test/stdlib/Module_test.rb           | 30 +++++++++++++++++++++++++---
 3 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/core/module.rbs b/core/module.rbs
index 9c6dc9c6f..c07193b57 100644
--- a/core/module.rbs
+++ b/core/module.rbs
@@ -348,7 +348,7 @@ class Module
   #
   # Files that are currently being loaded must not be registered for autoload.
   #
-  def autoload: (interned constant, String filename) -> NilClass
+  def autoload: (interned constant, path filename) -> nil
 
   # <!--
   #   rdoc-file=load.c
@@ -829,7 +829,7 @@ class Module
 
   # <!--
   #   rdoc-file=object.c
-  #   -   (othermod)
+  #   - extended(othermod)
   # -->
   # The equivalent of `included`, but for extended modules.
   #
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index 2fdb3856b..dee8345ca 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -296,8 +296,13 @@ def assert_const_type(type, constant_name)
         assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
       end
 
-      def assert_visibility(vis, receiver, method)
-        puts 'TODO: visibility for types'
+      def assert_visibility(visibility, receiver, method)
+        _, definition = target
+        method_entry = definition.methods[method]
+
+        assert method_entry, "Method `#{method}` not found in RBS definition"
+        assert_equal visibility, method_entry.accessibility,
+          "Expected `#{method}` to be #{visibility}, but was #{method_entry.accessibility}"
       end
 
       def assert_type(type, value)
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 99af2bac3..866298318 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -511,11 +511,35 @@ def test_ancestors
   end
 
   def test_autoload
-    omit 'todo'
+    with_interned :Constant do |constant|
+      with_path do |path|
+        assert_send_type  '(interned, path) -> nil',
+                          Module.new, :autoload, constant, path
+      end
+    end
   end
 
   def test_autoload?
-    omit 'todo'
+    autoloaded = Module.new
+    autoloaded.autoload(:Constant, 'Bar')
+
+    with_interned :Constant do |constant|
+      assert_send_type  '(interned) -> nil',
+                        Module.new, :autoload?, constant
+      assert_send_type  '(interned) -> String',
+                        autoloaded, :autoload?, constant
+      assert_send_type  '(interned) -> String',
+                        Module.new.include(autoloaded), :autoload?, constant
+
+      with_boolish do |inherit|
+        assert_send_type  '(interned, boolish) -> nil',
+                          Module.new, :autoload?, constant, inherit
+        assert_send_type  '(interned, boolish) -> String',
+                          autoloaded, :autoload?, constant, inherit
+        assert_send_type  '(interned, boolish) -> String?',
+                          Module.new.include(autoloaded), :autoload?, constant, inherit
+      end
+    end
   end
 
   def test_class_variable_defined?
@@ -1264,6 +1288,6 @@ def test_using
                       Module.new, :using
 
     # Cant actually test `using` in modules, so this is the best we got
-    assert_type 'Module', UsingModule::UsingModule
+    assert_type 'Module', UsingModule::UsingReturnValue
   end
 end

From 205f42c9057ddebdfb9d86f767014d80a3189757 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Tue, 14 Apr 2026 16:29:08 -0700
Subject: [PATCH 11/11] cleanup of assert_visibility

---
 lib/rbs/unit_test/type_assertions.rb |  4 +--
 sig/unit_test/type_assertions.rbs    |  4 +++
 test/stdlib/Module_test.rb           | 51 ++++++++++------------------
 3 files changed, 24 insertions(+), 35 deletions(-)

diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index 4370f8421..6794218a2 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -323,12 +323,12 @@ def assert_const_type(type, constant_name)
         assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
       end
 
-      def assert_visibility(visibility, receiver, method)
+      def assert_visibility(visibility, method)
         _, definition = target
         method_entry = definition.methods[method]
 
         assert method_entry, "Method `#{method}` not found in RBS definition"
-        assert_equal visibility, method_entry.accessibility,
+        assert visibility == method_entry.accessibility,
           "Expected `#{method}` to be #{visibility}, but was #{method_entry.accessibility}"
       end
 
diff --git a/sig/unit_test/type_assertions.rbs b/sig/unit_test/type_assertions.rbs
index 9e7d32fc5..253a8fb18 100644
--- a/sig/unit_test/type_assertions.rbs
+++ b/sig/unit_test/type_assertions.rbs
@@ -179,6 +179,10 @@ module RBS
       #
       def assert_type: (String | Types::t value_type, untyped value) -> void
 
+      # Asserts if given `value` has a type of `value_type`
+      #
+      def assert_visibility: (:private | :public visibility, Symbol method_name) -> void
+
       # Allow non _simple-type_ method types given to `assert_send_type` and `refute_send_type`
       #
       # ```ruby
diff --git a/test/stdlib/Module_test.rb b/test/stdlib/Module_test.rb
index 866298318..25d1a1288 100644
--- a/test/stdlib/Module_test.rb
+++ b/test/stdlib/Module_test.rb
@@ -133,11 +133,10 @@ def test_prepend
   end
 
   def test_refine
+    assert_visibility :private, :refine
+
     assert_send_type "(Module) { () -> void } -> Refinement",
                      RefinedModule, :refine, Integer do nil end
-
-    assert_visibility :private,
-                      RefinedModule, :refine
   end
 
   def test_refinements
@@ -212,8 +211,7 @@ def foo; end
       def bar; end
     end
 
-    assert_visibility :private,
-                      mod, :module_function
+    assert_visibility :private, :module_function
 
     # No arguments
     assert_send_type  '() -> nil',
@@ -281,8 +279,8 @@ def foo; end
       def bar; end
     end
 
-    assert_visibility :private,
-                      mod, visibility
+    assert_visibility :private, visibility
+
     # No arguments
     assert_send_type  '() -> nil',
                       mod, visibility
@@ -471,8 +469,7 @@ def foo(*x) = 3
       def bar(*x) = 3
     end
 
-    assert_visibility :private,
-                      mod, :ruby2_keywords
+    assert_visibility :private, :ruby2_keywords
 
     with_interned :foo do |foo|
       assert_send_type  '(interned) -> nil',
@@ -1101,16 +1098,14 @@ def foo = 4
   end
 
   def test_append_features
-    assert_visibility :private,
-                      Module.new, :append_features
+    assert_visibility :private, :append_features
 
     assert_send_type  '(Module) -> Module',
                       Module.new, :append_features, Module.new
   end
 
   def test_const_added
-    assert_visibility :private,
-                      Module.new, :const_added
+    assert_visibility :private, :const_added
 
     # const_added directly works
     assert_send_type  '(Symbol) -> void',
@@ -1138,8 +1133,7 @@ def test_const_added
   end
 
   def test_extend_object
-    assert_visibility :private,
-                      Module.new, :extend_object
+    assert_visibility :private, :extend_object
 
     with_untyped_singleton_possible do |untyped|
       assert_send_type  '[T] (T) -> T',
@@ -1152,8 +1146,7 @@ def test_extend_object
   end
 
   def test_extended
-    assert_visibility :private,
-                      Module.new, :extended
+    assert_visibility :private, :extended
 
     with_untyped_singleton_possible do |untyped|
       assert_send_type  '(untyped) -> void',
@@ -1166,8 +1159,7 @@ def test_extended
   end
 
   def test_included
-    assert_visibility :private,
-                      Module.new, :included
+    assert_visibility :private, :included
 
     assert_send_type  '(Module) -> void',
                       Module.new, :included, Module.new
@@ -1177,8 +1169,7 @@ def test_included
   end
 
   def test_method_added
-    assert_visibility :private,
-                      Module.new, :method_added
+    assert_visibility :private, :method_added
 
 
     # method_added directly works
@@ -1200,8 +1191,7 @@ def test_method_added
   end
 
   def test_method_removed
-    assert_visibility :private,
-                      Module.new, :method_removed
+    assert_visibility :private, :method_removed
 
     # method_removed directly works
     assert_send_type  '(Symbol) -> void',
@@ -1222,8 +1212,7 @@ def test_method_removed
   end
 
   def test_method_undefined
-    assert_visibility :private,
-                      Module.new, :method_undefined
+    assert_visibility :private, :method_undefined
 
     # method_undefined directly works
     assert_send_type  '(Symbol) -> void',
@@ -1244,8 +1233,7 @@ def test_method_undefined
   end
 
   def test_prepend_features
-    assert_visibility :private,
-                      Module.new, :prepend_features
+    assert_visibility :private, :prepend_features
 
     assert_send_type  '(Module) -> Module',
                       Module.new, :prepend_features, Module.new
@@ -1255,8 +1243,7 @@ def test_prepend_features
   end
 
   def test_prepended
-    assert_visibility :private,
-                      Module.new, :prepended
+    assert_visibility :private, :prepended
 
     assert_send_type  '(Module) -> void',
                       Module.new, :prepended, Module.new
@@ -1266,8 +1253,7 @@ def test_prepended
   end
 
   def test_remove_const
-    assert_visibility :private,
-                      Module.new, :remove_const
+    assert_visibility :private, :remove_const
 
     with_interned :Foo do |name|
       mod = Module.new
@@ -1284,8 +1270,7 @@ module UsingModule
   end
 
   def test_using
-    assert_visibility :private,
-                      Module.new, :using
+    assert_visibility :private, :using
 
     # Cant actually test `using` in modules, so this is the best we got
     assert_type 'Module', UsingModule::UsingReturnValue