diff --git a/core/module.rbs b/core/module.rbs
index db395a91e..b201a7c21 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
@@ -163,7 +163,7 @@ class Module < Object
   #     # 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
@@ -254,7 +254,7 @@ class Module < Object
   #
   #     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
@@ -273,7 +273,7 @@ class Module < Object
   #     Math.ancestors       #=> [Math]
   #     Enumerable.ancestors #=> [Enumerable]
   #
-  def ancestors: () -> ::Array[Module]
+  def ancestors: () -> Array[Module]
 
   # <!--
   #   rdoc-file=eval.c
@@ -285,7 +285,7 @@ class Module < Object
   # 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
@@ -303,7 +303,7 @@ class Module < Object
   #     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
@@ -317,7 +317,7 @@ class Module < Object
   # name 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
@@ -328,7 +328,7 @@ class Module < Object
   # *symbol*<code>.id2name</code>. 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
@@ -349,7 +349,7 @@ class Module < Object
   #
   # Files that are currently being loaded must not be registered for autoload.
   #
-  def autoload: (interned _module, String filename) -> NilClass
+  def autoload: (interned constant, path filename) -> nil
 
   # <!--
   #   rdoc-file=load.c
@@ -397,8 +397,7 @@ class Module < Object
   #     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
@@ -417,7 +416,7 @@ class Module < Object
   #
   #     Hello there!
   #
-  def class_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U
+  alias class_exec module_exec
 
   # <!--
   #   rdoc-file=object.c
@@ -433,7 +432,7 @@ class Module < Object
   #     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
@@ -449,7 +448,7 @@ class Module < Object
   #     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
@@ -468,7 +467,7 @@ class Module < Object
   #     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
@@ -488,7 +487,7 @@ class Module < Object
   #     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
@@ -533,7 +532,7 @@ class Module < Object
   #     :const_added
   #     :inherited
   #
-  private def const_added: (Symbol) -> void
+  private def const_added: (Symbol const_name) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -652,7 +651,7 @@ class Module < Object
   #       const_get(name, false)
   #     end
   #
-  def const_missing: (Symbol arg0) -> untyped
+  def const_missing: (Symbol name) -> untyped
 
   # <!--
   #   rdoc-file=object.c
@@ -670,7 +669,7 @@ class Module < Object
   #
   #     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
@@ -739,7 +738,7 @@ class Module < Object
   #
   # Also see Module#const_defined?.
   #
-  def constants: (?boolish inherit) -> ::Array[Symbol]
+  def constants: (?boolish inherit) -> Array[Symbol]
 
   # <!--
   #   rdoc-file=proc.c
@@ -799,7 +798,7 @@ class Module < Object
   #     HTTP::NOT_FOUND
   #     # warning: constant HTTP::NOT_FOUND is deprecated
   #
-  def deprecate_constant: (*interned) -> self
+  def deprecate_constant: (*interned names) -> self
 
   def equal?: (untyped other) -> bool
 
@@ -829,7 +828,7 @@ class Module < Object
   #     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
@@ -847,7 +846,7 @@ class Module < Object
   #     end
   #      # => prints "A extended in Enumerable"
   #
-  private def extended: (Module othermod) -> untyped
+  private def extended: (untyped othermod) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -865,7 +864,7 @@ class Module < Object
   # -->
   # 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
@@ -905,7 +904,7 @@ class Module < Object
   #     end
   #      # => prints "A included in Enumerable"
   #
-  private def included: (Module othermod) -> untyped
+  private def included: (Module othermod) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -928,7 +927,7 @@ class Module < Object
   #     Mixin.included_modules   #=> [Sub]
   #     Outer.included_modules   #=> [Sub, Mixin]
   #
-  def included_modules: () -> ::Array[Module]
+  def included_modules: () -> Array[Module]
 
   # <!--
   #   rdoc-file=object.c
@@ -955,8 +954,9 @@ class Module < Object
   # 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
@@ -987,7 +987,7 @@ class Module < Object
   #
   #     Hello there, Dave!
   #
-  def instance_method: (interned arg0) -> UnboundMethod
+  def instance_method: (interned name) -> UnboundMethod
 
   # <!--
   #   rdoc-file=object.c
@@ -1024,7 +1024,7 @@ class Module < Object
   #     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
@@ -1044,7 +1044,7 @@ class Module < Object
   #
   #     Adding :some_instance_method
   #
-  private def method_added: (Symbol meth) -> untyped
+  private def method_added: (Symbol method_name) -> void
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1105,7 +1105,7 @@ class Module < Object
   #
   #     Removing :some_instance_method
   #
-  private def method_removed: (Symbol method_name) -> untyped
+  private def method_removed: (Symbol method_name) -> void
 
   # <!--
   #   rdoc-file=object.c
@@ -1130,7 +1130,7 @@ class Module < Object
   #
   #     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
@@ -1158,8 +1158,8 @@ class Module < Object
   #     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
@@ -1225,9 +1225,11 @@ class Module < Object
   #
   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
@@ -1243,7 +1245,7 @@ class Module < Object
   # -->
   # 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
@@ -1255,7 +1257,7 @@ class Module < Object
   # 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
@@ -1273,7 +1275,7 @@ class Module < Object
   #     end
   #      # => prints "A prepended to Enumerable"
   #
-  private def prepended: (Module othermod) -> untyped
+  private def prepended: (Module othermod) -> void
 
   # <!--
   #   rdoc-file=vm_method.c
@@ -1302,10 +1304,14 @@ class Module < Object
   #
   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
@@ -1327,8 +1333,8 @@ class Module < Object
   #       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
@@ -1336,7 +1342,7 @@ class Module < Object
   # -->
   # Makes a list of existing constants private.
   #
-  def private_constant: (*interned arg0) -> self
+  def private_constant: (*interned names) -> self
 
   # <!--
   #   rdoc-file=object.c
@@ -1353,7 +1359,7 @@ class Module < Object
   #     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
@@ -1443,10 +1449,14 @@ class Module < Object
   #
   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
@@ -1455,7 +1465,7 @@ class Module < Object
   # 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
@@ -1503,10 +1513,14 @@ class Module < Object
   #
   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
@@ -1519,8 +1533,8 @@ class Module < Object
   # 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
@@ -1528,7 +1542,7 @@ class Module < Object
   # -->
   # Makes a list of existing constants public.
   #
-  def public_constant: (*interned arg0) -> self
+  def public_constant: (*interned names) -> self
 
   # <!--
   #   rdoc-file=proc.c
@@ -1545,7 +1559,7 @@ class Module < Object
   # 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
@@ -1627,7 +1641,7 @@ class Module < Object
   #     99
   #     nil
   #
-  def remove_class_variable: (interned arg0) -> untyped
+  def remove_class_variable: (interned name) -> untyped
 
   # <!--
   #   rdoc-file=object.c
@@ -1637,7 +1651,7 @@ class Module < Object
   # 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
@@ -1647,7 +1661,7 @@ class Module < Object
   # 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
@@ -1684,7 +1698,7 @@ class Module < Object
   # 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
@@ -1733,7 +1747,7 @@ class Module < Object
   #     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
@@ -1817,14 +1831,14 @@ class Module < Object
   # 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
   # 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
@@ -1837,6 +1851,6 @@ class Module < Object
   # to <code>attr_reader(name)</code> 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]
 end
diff --git a/lib/rbs/unit_test/type_assertions.rb b/lib/rbs/unit_test/type_assertions.rb
index 92eb496c3..6794218a2 100644
--- a/lib/rbs/unit_test/type_assertions.rb
+++ b/lib/rbs/unit_test/type_assertions.rb
@@ -323,6 +323,15 @@ 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, method)
+        _, definition = target
+        method_entry = definition.methods[method]
+
+        assert method_entry, "Method `#{method}` not found in RBS definition"
+        assert visibility == method_entry.accessibility,
+          "Expected `#{method}` to be #{visibility}, but was #{method_entry.accessibility}"
+      end
+
       def assert_type(type, value)
         typecheck = RBS::Test::TypeCheck.new(
           self_class: value.class,
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 d4b285333..25d1a1288 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
 
@@ -30,65 +50,158 @@ def foo(meth, *args, &block)
     end
   end
 
+  module RefinedModule
+    refine String do
+    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?',
+                        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
-    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_visibility :private, :refine
+
     assert_send_type "(Module) { () -> void } -> Refinement",
-                     Foo, :refine, String do nil end
+                     RefinedModule, :refine, Integer do nil end
   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
-  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
-
-    assert_send_type "() { (Module) -> nil } -> nil",
-                     Foo, :module_eval do nil end
+    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(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
+
+  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
@@ -98,44 +211,51 @@ 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, :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
@@ -144,297 +264,1015 @@ 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 classlevel_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"]
-    )
+    assert_visibility :private, 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
+
+    with_interned 'foo' do |foo|
+      assert_send_type  '(interned) -> interned',
+                        mod, visibility, foo
+    end
+
+    # Multiple arguments
+    assert_send_type  '(Symbol, *Symbol) -> Array[Symbol]',
+                      mod, visibility, :foo, :bar
+
+    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
+
+    with_interned 'foo' do |foo|
+      with_interned 'bar' do |bar|
+        assert_send_type  '(interned, *interned) -> Array[interned]',
+                          mod, visibility, foo, bar
+      end
+    end
+
+    # With the array version
+    assert_send_type  '(Array[Symbol]) -> Array[Symbol]',
+                      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_private
+    classlevel_visibility_helper(:private)
+  end
+
+  def test_protected
+    classlevel_visibility_helper(:protected)
+  end
+
+  def test_public
+    classlevel_visibility_helper(:public)
+  end
+
+
   def test_private_class_method
     mod = Module.new do
       def self.foo; end
       def self.bar; end
     end
 
-    assert_send_type(
-      "(Symbol) -> Module",
-      mod, :private_class_method, :foo
-    )
-
-    assert_send_type(
-      "(Symbol, Symbol) -> Module",
-      mod, :private_class_method, :foo, :bar
-    )
+    disable_verbose do
+      assert_send_type  '() -> Module',
+                        mod, :private_class_method
+    end
 
-    assert_send_type(
-      "(String) -> Module",
-      mod, :private_class_method, "foo"
-    )
+    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(
-      "(String, String) -> Module",
-      mod, :private_class_method, "foo", "bar"
-    )
+    disable_verbose do
+      assert_send_type  '() -> Module',
+                        mod, :public_class_method
+    end
 
-    assert_send_type(
-      "(Array[Symbol | String]) -> Module",
-      mod, :private_class_method, [:foo, "bar"]
-    )
+    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
 
-  def test_protected
-    mod = Module.new do
-      def foo; end
+  def test_attr
+    assert_send_type  '() -> Array[Symbol]',
+                       Module.new, :attr
+
+    with_interned :foo do |foo|
+      with_bool do |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
 
-      def bar; end
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        Module.new, :attr, foo
+
+      with_interned :bar do |bar|
+        assert_send_type  '(*interned) -> Array[Symbol]',
+                          Module.new, :attr, foo, bar
+      end
     end
+  end
+
+  def test_attr_reader
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :attr_reader
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        Module.new, :attr_reader, foo
 
-    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"]
-    )
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          Module.new, :attr_reader, foo, bar
+      end
+    end
   end
 
-  def test_public
-    mod = Module.new do
-      def foo; end
+  def test_attr_writer
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :attr_writer
 
-      def bar; end
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        Module.new, :attr_writer, foo
+
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          Module.new, :attr_writer, foo, bar
+      end
     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"]
-    )
+  def test_attr_accessor
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :attr_accessor
+
+    with_interned :foo do |foo|
+      assert_send_type  '(interned) -> Array[Symbol]',
+                        Module.new, :attr_accessor, foo
+
+      with_interned :bar do |bar|
+        assert_send_type  '(interned, interned) -> Array[Symbol]',
+                          Module.new, :attr_accessor, foo, bar
+      end
+    end
   end
 
-  def test_public_class_method
+  def test_ruby2_keywords
     mod = Module.new do
-      def self.foo; end
-      def self.bar; end
+      def foo(*x) = 3
+      def bar(*x) = 3
     end
 
-    assert_send_type(
-      "(Symbol) -> Module",
-      mod, :public_class_method, :foo
-    )
+    assert_visibility :private, :ruby2_keywords
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Module",
-      mod, :public_class_method, :foo, :bar
-    )
+    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
 
-    assert_send_type(
-      "(String) -> Module",
-      mod, :public_class_method, "foo"
-    )
+  def test_set_temporary_name
+    assert_send_type '(nil) -> Module',
+                     Module.new, :set_temporary_name, nil
 
-    assert_send_type(
-      "(String, String) -> Module",
-      mod, :public_class_method, "foo", "bar"
-    )
+    with_string "fake_name" do |name|
+      assert_send_type '(string) -> Module',
+                       Module.new, :set_temporary_name, name
+    end
+  end
 
-    assert_send_type(
-      "(Array[Symbol | String]) -> Module",
-      mod, :public_class_method, [:foo, "bar"]
-    )
+  def test_to_s(method: :to_s)
+    assert_send_type  '() -> String',
+                      Module.new, method
   end
 
-  def test_attr
+  def test_inspect
+    test_to_s(method: :inspect)
+  end
+
+  def test_ancestors
+    assert_send_type  '() -> Array[Module]',
+                      Module.new, :ancestors
+    assert_send_type  '() -> Array[Module]',
+                      Module, :ancestors
+  end
+
+  def test_autoload
+    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?
+    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?
     mod = Module.new
-    assert_send_type(
-      "(*interned arg0) -> Array[Symbol]",
-      mod, :attr, :foo
-    )
+
+    with_interned :@@module_test_class_variable_defined do |cvar|
+      assert_send_type "(interned) -> bool",
+                       mod, :class_variable_defined?, cvar
+    end
+
+    mod.class_variable_set :@@module_test_class_variable_defined, 12
+    with_interned :@@module_test_class_variable_defined do |cvar|
+      assert_send_type "(interned) -> bool",
+                       mod, :class_variable_defined?, cvar
+    end
   end
 
-  def test_attr_reader
+  def test_class_variable_get
+    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 |cvar|
+      assert_send_type "(interned) -> untyped",
+                       mod, :class_variable_get, cvar
+    end
+  end
+
+  def test_class_variable_set
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_reader, :foo
-    )
+    with_interned :@@module_test_class_variable_set do |cvar|
+      with_untyped do |value|
+        assert_send_type "[T] (interned, T) -> T",
+                         mod, :class_variable_set, cvar, value
+      end
+    end
+  end
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_reader, :foo, :bar
-    )
+  def test_class_variables
+    mod = Module.new do
+      include Module.new {
+        class_variable_set :@@module_test_class_variables_1, 12
+      }
 
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_reader, "foo"
-    )
+      class_variable_set :@@module_test_class_variables_2, 34
+    end
 
-    assert_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_reader, "foo", "bar"
-    )
+    assert_send_type  '() -> Array[Symbol]',
+                      Module.new, :class_variables
+    assert_send_type  '() -> Array[Symbol]',
+                      mod, :class_variables
 
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_reader, :foo, "bar"
-    )
+    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_attr_writer
+  def test_const_defined?
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_writer, :foo
-    )
+    # Before defining the constant
+    with_interned :ModuleTestConstDefined do |name|
+      assert_send_type '(interned) -> bool',
+                       mod, :const_defined?, name
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_writer, :foo, :bar
-    )
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> bool',
+                         mod, :const_defined?, name, inherit
+      end
+    end
 
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_writer, "foo"
-    )
+    mod.const_set :ModuleTestConstDefined, 123
 
-    assert_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_writer, "foo", "bar"
-    )
+    # After defining the constant
+    with_interned :ModuleTestConstDefined do |name|
+      assert_send_type '(interned) -> bool',
+                       mod, :const_defined?, name
 
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_writer, :foo, "bar"
-    )
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> bool',
+                         mod, :const_defined?, name, inherit
+      end
+    end
   end
 
-  def test_attr_accessor
+  def test_const_get
     mod = Module.new
 
-    assert_send_type(
-      "(Symbol) -> Array[Symbol]",
-      mod, :attr_accessor, :foo
-    )
+    # Define the constant first to avoid NameError paths
+    mod.const_set :ModuleTestConstGet, 123
 
-    assert_send_type(
-      "(Symbol, Symbol) -> Array[Symbol]",
-      mod, :attr_accessor, :foo, :bar
-    )
+    with_interned :ModuleTestConstGet do |name|
+      assert_send_type '(interned) -> untyped',
+                       mod, :const_get, name
 
-    assert_send_type(
-      "(String) -> Array[Symbol]",
-      mod, :attr_accessor, "foo"
-    )
+      with_boolish do |inherit|
+        assert_send_type '(interned, boolish) -> untyped',
+                         mod, :const_get, name, inherit
+      end
+    end
+  end
+
+  def test_const_missing
+    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_send_type(
-      "(String, String) -> Array[Symbol]",
-      mod, :attr_accessor, "foo", "bar"
-    )
+    assert_type 'Rational',
+                mod::Foo # Test the `::` syntax works
 
-    assert_send_type(
-      "(Symbol, String) -> Array[Symbol]",
-      mod, :attr_accessor, :foo, "bar"
-    )
+    # 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_ruby2_keywords
-    assert_send_type(
-      "(Symbol) -> nil",
-      Foo, :ruby2_keywords, :foo
-    )
+  def test_const_set
+    with_interned :ModuleTestConstSet do |name|
+      with_untyped do |value|
+        assert_send_type '[T] (interned, T) -> T',
+                         Module.new, :const_set, name, value
+      end
+    end
   end
 
-  def test_set_temporary_name
-    mod = Module.new
+  def test_define_method
+    with_interned :meth do |name|
+      assert_send_type  '(interned, ^(?) [self: top] -> untyped) -> Symbol',
+                        Module.new, :define_method, name, proc {}
 
-    with_string "fake_name" do |name|
-      assert_send_type(
-        "(::string) -> ::Module",
-        mod, :set_temporary_name, name
-      )
+      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)
+    mod = Module.new do
+      const_set :Foo, 3
+      const_set :Bar, 4
+    end
+
+    # No arguments yields a warning with `-w`
+    disable_verbose do
+      assert_send_type  '() -> Module',
+                        mod, method
+    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
+    constant_visibility_helper(:deprecate_constant)
+  end
+
+  def test_freeze
+    assert_send_type  '() -> Module',
+                      Module.new, :freeze
+  end
+
+  def test_included_modules
+    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
+    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
+    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
+    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
+    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?
+    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
+    assert_send_type  '() -> nil',
+                      Module.new, :name
+
+    assert_send_type  '() -> String',
+                      Comparable, :name
+  end
+
+  def test_private_constant
+    constant_visibility_helper(:private_constant)
+  end
+
+  def test_private_instance_methods
+    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?
+    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
+    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?
+    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
+    constant_visibility_helper(:public_constant)
+  end
+
+  def test_public_instance_method
+    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
+    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?
+    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
+    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
+    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?
+    assert_send_type  '() -> bool',
+                      Module, :singleton_class?
+    assert_send_type  '() -> bool',
+                      Module.singleton_class, :singleton_class?
+  end
+
+  def test_undef_method
+    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
+    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
+    assert_visibility :private, :append_features
+
+    assert_send_type  '(Module) -> Module',
+                      Module.new, :append_features, Module.new
+  end
+
+  def test_const_added
+    assert_visibility :private, :const_added
+
+    # 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, :extend_object
+
+    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, :extended
+
+    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, :included
+
+    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, :method_added
+
+
+    # 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, :method_removed
+
+    # 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, :method_undefined
+
+    # 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, :prepend_features
+
+    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, :prepended
+
+    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, :remove_const
+
+    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, :using
 
-    assert_send_type(
-      "(nil) -> Module",
-      mod, :set_temporary_name, nil
-    )
+    # Cant actually test `using` in modules, so this is the best we got
+    assert_type 'Module', UsingModule::UsingReturnValue
   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
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index 204cbdecc..b11939079 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
 
   def silence_warning(which)