updates continued

Author: sampersand

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

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