sorbet-runtime 0.5.10782 → 0.5.10993

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 775572c19008cfccf4857dea03c7a20af6425eeb6e9c252d7411b6d07b102bd7
-  data.tar.gz: 4372ece549f9e340865242ad15e0b3d1bb4ecf5e1532f1867bc7d315a4ae95ca
+  metadata.gz: a0f91e65ae1b0e498c5df805b8f45638368257bba5b57c83153d73468c93c902
+  data.tar.gz: c183a3eb926674965fb519fe6fd03450151134fd14e494d3cf9cbdb2214fefb3
 SHA512:
-  metadata.gz: df20b3fbeb6e4d7c2abafcb49d029d35acc6c4c3c4a94768b32653d9c5377726db173c7f93719549c4271baddf74d7736ab2d90c4543cb0116cd59a355f7535b
-  data.tar.gz: 15d21f62ed38ce9cd1c132b63e4639ab19aed9c29abe2bfbb79fbdbf10d0372abdc8595b748110fe33f7cdf83b65cdaa034e64a55e9267d2e46fed53e790fda1
+  metadata.gz: a4e0e8d924176d843836921e5b8de7b768ec85636aaba35d05e8329225bf92854e979a8c6e8ee373de5568c2fc1f57f3a1b069197c0b6849942561f7cd16e395
+  data.tar.gz: c75f0f7590bc1b1e481f674e537497b69969bebeaa8866cea12994e63b62d3366dad7fbc583cdfff7c67392e76294374ef16e1946234ecc9be1ae4429211152b

data/lib/sorbet-runtime.rb

@@ -85,6 +85,7 @@ require_relative 'types/boolean'
 
 # Depends on types/utils
 require_relative 'types/types/typed_array'
+require_relative 'types/types/typed_class'
 
 # Props dependencies
 require_relative 'types/private/abstract/data'

data/lib/types/_types.rb

@@ -123,7 +123,7 @@ module T
   #  .returns(T::Array[T.type_parameter(:U)])
   #  def map(&blk); end
   def self.type_parameter(name)
-    T::Types::TypeParameter.new(name)
+    T::Types::TypeParameter.make(name)
   end
 
   # Tells the typechecker that `value` is of type `type`. Use this to get additional checking after
@@ -355,4 +355,16 @@ module T
       end
     end
   end
+
+  module Class
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedClass::Untyped::Private::INSTANCE
+      elsif type.is_a?(T::Types::Anything)
+        T::Types::TypedClass::Anything::Private::INSTANCE
+      else
+        T::Types::TypedClass::Private::Pool.type_for_module(type)
+      end
+    end
+  end
 end

data/lib/types/enum.rb

@@ -357,7 +357,7 @@ class T::Enum
     @fully_initialized = true
   end
 
-  sig {params(child_class: Module).void}
+  sig {params(child_class: T::Class[T.anything]).void}
   def self.inherited(child_class)
     super
 

data/lib/types/private/abstract/declare.rb

@@ -27,26 +27,27 @@ module T::Private::Abstract::Declare
         raise "Classes can't be interfaces. Use `abstract!` instead of `interface!`."
       end
 
-      if mod.instance_method(:initialize).owner == mod
-        raise "You must call `abstract!` *before* defining an initialize method"
+      if Object.instance_method(:method).bind_call(mod, :new).owner == mod
+        raise "You must call `abstract!` *before* defining a `new` method"
       end
 
       # Don't need to silence warnings via without_ruby_warnings when calling
       # define_method because of the guard above
 
-      mod.send(:define_method, :initialize) do |*args, &blk|
-        if self.class == mod
-          raise "#{mod} is declared as abstract; it cannot be instantiated"
+      mod.send(:define_singleton_method, :new) do |*args, &blk|
+        super(*args, &blk).tap do |result|
+          if result.instance_of?(mod)
+            raise "#{mod} is declared as abstract; it cannot be instantiated"
+          end
         end
-        super(*args, &blk)
       end
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods
       # (more robust than undef_method that would create a small window in which the method doesn't exist)
-      mod.send(:alias_method, :initialize, :initialize)
+      mod.singleton_class.send(:alias_method, :new, :new)
 
-      if mod.respond_to?(:ruby2_keywords, true)
-        mod.send(:ruby2_keywords, :initialize)
+      if mod.singleton_class.respond_to?(:ruby2_keywords, true)
+        mod.singleton_class.send(:ruby2_keywords, :new)
       end
     end
   end

data/lib/types/private/class_utils.rb

@@ -91,10 +91,13 @@ module T::Private::ClassUtils
   end
 
   # Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by
-  # overriding it (if it is defined by one of mod's ancestors). Returns a ReplacedMethod instance
-  # on which you can call `bind(...).call(...)` to call the original method, or `restore` to
-  # restore the original method (by overwriting or removing the override).
-  def self.replace_method(mod, name, &blk)
+  # overriding it (if it is defined by one of mod's ancestors).  If `original_only` is
+  # false, returns a ReplacedMethod instance on which you can call `bind(...).call(...)`
+  # to call the original method, or `restore` to restore the original method (by
+  # overwriting or removing the override).
+  #
+  # If `original_only` is true, return the `UnboundMethod` representing the original method.
+  def self.replace_method(mod, name, original_only=false, &blk)
     original_method = mod.instance_method(name)
     original_visibility = visibility_method_name(mod, name)
     original_owner = original_method.owner
@@ -120,8 +123,12 @@ module T::Private::ClassUtils
         def_with_visibility(mod, name, original_visibility, &blk)
       end
     end
-    new_method = mod.instance_method(name)
 
-    ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+    if original_only
+      original_method
+    else
+      new_method = mod.instance_method(name)
+      ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+    end
   end
 end

data/lib/types/private/methods/_methods.rb

@@ -163,7 +163,7 @@ module T::Private::Methods
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations&.find {|l| !l.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
+        caller_loc = caller_locations.find {|l| !l.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -252,7 +252,7 @@ module T::Private::Methods
     # (or unwrap back to the original method).
     key = method_owner_and_name_to_key(mod, method_name)
     unless current_declaration.raw
-      T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(mod, method_name, true) do |*args, &blk|
         method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
         method_sig ||= T::Private::Methods._handle_missing_method_signature(
           self,
@@ -501,19 +501,37 @@ module T::Private::Methods
       return
     end
     if is_enabled
-      @old_hooks.each(&:restore)
+      # A cut-down version of T::Private::ClassUtils::ReplacedMethod#restore, because we
+      # should only be resetting final hooks during tests.
+      T::Configuration.without_ruby_warnings do
+        Module.define_method(:included, @old_hooks[0])
+        Module.define_method(:extended, @old_hooks[1])
+        Class.define_method(:inherited, @old_hooks[2])
+      end
       @old_hooks = nil
     else
-      old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
-        old_included.bind(self).call(arg)
+      old_included = T::Private::ClassUtils.replace_method(Module, :included, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_included.bind_call(self, arg)
+        else
+          old_included.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
-      old_extended = T::Private::ClassUtils.replace_method(Module, :extended) do |arg|
-        old_extended.bind(self).call(arg)
+      old_extended = T::Private::ClassUtils.replace_method(Module, :extended, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_extended.bind_call(self, arg)
+        else
+          old_extended.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
-      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited) do |arg|
-        old_inherited.bind(self).call(arg)
+      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_inherited.bind_call(self, arg)
+        else
+          old_inherited.bind(self).call(arg)
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]

data/lib/types/private/methods/call_validation.rb

@@ -14,7 +14,7 @@ module T::Private::Methods::CallValidation
   def self.wrap_method_if_needed(mod, method_sig, original_method)
     original_visibility = visibility_method_name(mod, method_sig.method_name)
     if method_sig.mode == T::Private::Methods::Modes.abstract
-      T::Private::ClassUtils.replace_method(mod, method_sig.method_name) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(mod, method_sig.method_name, true) do |*args, &blk|
         # TODO: write a cop to ensure that abstract methods have an empty body
         #
         # We allow abstract methods to be implemented by things further down the ancestor chain.

data/lib/types/private/methods/call_validation_2_6.rb

@@ -11,26 +11,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_fast'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -343,26 +345,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -608,26 +612,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_medium'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end
@@ -940,26 +946,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end

data/lib/types/private/methods/call_validation_2_7.rb

@@ -11,26 +11,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_fast'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -343,26 +345,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1].raw_type)
+    when 2
       create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
       create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
       create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
     else
       raise 'should not happen'
     end
@@ -608,26 +612,28 @@ module T::Private::Methods::CallValidation
       raise 'Should have used create_validator_procedure_medium'
     end
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end
@@ -940,26 +946,28 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
     # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
       create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
-    elsif method_sig.arg_types.length == 1
+    when 1
       create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
+                                    arg_types[0][1])
+    when 2
       create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
       create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
       create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
     else
       raise 'should not happen'
     end

data/lib/types/private/methods/decl_builder.rb

@@ -231,15 +231,17 @@ module T::Private::Methods
         decl.on_failure = nil
       end
       if decl.params.equal?(ARG_NOT_PROVIDED)
-        decl.params = {}
+        decl.params = FROZEN_HASH
       end
       if decl.type_parameters.equal?(ARG_NOT_PROVIDED)
-        decl.type_parameters = {}
+        decl.type_parameters = FROZEN_HASH
       end
 
       decl.finalized = true
 
       self
     end
+
+    FROZEN_HASH = {}.freeze
   end
 end