sorbet-runtime 0.5.10324 → 0.5.11267

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1adb9a8fbde97258c22cfe8b67725eccbf5227dc90d6f8907c76a3a2547f19d2
-  data.tar.gz: 5f98dea61861b348ecd7f7d6553cc0220566938280ef5e0c3bd0e91861146be6
+  metadata.gz: 62eef630524c0b1ad1f2a3d8749bd5f821a28ebfabbe7e4909010d530ffa698b
+  data.tar.gz: eb3fb942cb3ead21ec80e425726f823a6eb2cef834354ae2279a00c7fc5bf599
 SHA512:
-  metadata.gz: 4ae628db18157eaa445b200eae89737d317251378b14128ff86c3f9ea65ea3f72387734c4ce52e469a41ceee0507642eee2706c74c2b2082f245022c2ed04b3c
-  data.tar.gz: 63152be7a538c504777b332d8fc19408f63566a55c76f54875222732fc86e0e19efb56223b79ac60f64ba399dcccdbc3bb78f34a14ffef3e3347d20126c63c67
+  metadata.gz: 62855bc96c970aab1e89be225e336d6e7adc53b486137bb2f09457abdd9f932d23d4e6a37d05d6c8dad5d1fe098fad3b8cd4c529fcb7926e0bfefdc7b63249f3
+  data.tar.gz: d14d50ff7afbcad3fb245d2e9f815857c389b90a619fce352eca24da6be967728b748c89bac041ab71beed0f9bf4bf690c19a08b193d9ec701f0364026b7bc2b

data/lib/sorbet-runtime.rb

@@ -19,6 +19,7 @@ module T::Private::Types; end
 require_relative 'types/configuration'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
+require_relative 'types/private/caller_utils'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
@@ -37,14 +38,15 @@ require_relative 'types/types/fixed_array'
 require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
+require_relative 'types/types/anything'
 require_relative 'types/types/proc'
 require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
 require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
-require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
+require_relative 'types/types/typed_enumerator_chain'
 require_relative 'types/types/typed_enumerator_lazy'
 require_relative 'types/types/typed_hash'
 require_relative 'types/types/typed_range'
@@ -55,6 +57,7 @@ require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
 require_relative 'types/private/types/type_alias'
+require_relative 'types/private/types/simple_pair_union'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -71,7 +74,6 @@ require_relative 'types/private/abstract/validate'
 
 # Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
 require_relative 'types/generic'
-require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
@@ -81,6 +83,10 @@ require_relative 'types/private/retry'
 require_relative 'types/utils'
 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'
 require_relative 'types/private/mixins/mixins'

data/lib/types/_types.rb

@@ -47,6 +47,10 @@ module T
     T::Types::NoReturn::Private::INSTANCE
   end
 
+  def self.anything
+    T::Types::Anything::Private::INSTANCE
+  end
+
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
   def self.all(type_a, type_b, *types)
     T::Types::Intersection.new([type_a, type_b] + types)
@@ -119,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
@@ -130,7 +134,7 @@ module T
   def self.cast(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.cast")
+    Private::Casts.cast(value, type, "T.cast")
   end
 
   # Tells the typechecker to declare a variable of type `type`. Use
@@ -145,7 +149,7 @@ module T
   def self.let(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.let")
+    Private::Casts.cast(value, type, "T.let")
   end
 
   # Tells the type checker to treat `self` in the current block as `type`.
@@ -164,7 +168,7 @@ module T
   def self.bind(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.bind")
+    Private::Casts.cast(value, type, "T.bind")
   end
 
   # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
@@ -174,7 +178,7 @@ module T
   def self.assert_type!(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.assert_type!")
+    Private::Casts.cast(value, type, "T.assert_type!")
   end
 
   # For the static type checker, strips all type information from a value
@@ -221,6 +225,34 @@ module T
     end
   end
 
+  # A convenience method to `raise` with a provided error reason when the argument
+  # is `nil` and return it otherwise.
+  #
+  # Intended to be used as:
+  #
+  #   needs_foo(T.must_because(maybe_gives_foo) {"reason_foo_should_not_be_nil"})
+  #
+  # Equivalent to:
+  #
+  #   foo = maybe_gives_foo
+  #   raise "reason_foo_should_not_be_nil" if foo.nil?
+  #   needs_foo(foo)
+  #
+  # Intended to be used to promise sorbet that a given nilable value happens
+  # to contain a non-nil value at this point.
+  #
+  # `sig {params(arg: T.nilable(A), reason_blk: T.proc.returns(String)).returns(A)}`
+  def self.must_because(arg)
+    return arg if arg
+    return arg if arg == false
+
+    begin
+      raise TypeError.new("Unexpected `nil` because #{yield}")
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must_because', value: arg, type: nil})
+    end
+  end
+
   # A way to ask Sorbet to show what type it thinks an expression has.
   # This can be useful for debugging and checking assumptions.
   # In the runtime, merely returns the value passed in.
@@ -251,9 +283,9 @@ module T
   module Array
     def self.[](type)
       if type.is_a?(T::Types::Untyped)
-        T::Types::TypedArray::Untyped.new
+        T::Types::TypedArray::Untyped::Private::INSTANCE
       else
-        T::Types::TypedArray.new(type)
+        T::Types::TypedArray::Private::Pool.type_for_module(type)
       end
     end
   end
@@ -296,6 +328,16 @@ module T
         end
       end
     end
+
+    module Chain
+      def self.[](type)
+        if type.is_a?(T::Types::Untyped)
+          T::Types::TypedEnumeratorChain::Untyped.new
+        else
+          T::Types::TypedEnumeratorChain.new(type)
+        end
+      end
+    end
   end
 
   module Range
@@ -313,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/compatibility_patches.rb

@@ -27,8 +27,10 @@ if defined? ::RSpec::Mocks
       module RSpecCompatibility
         module RecorderExtensions
           def observe!(method_name)
-            method = @klass.instance_method(method_name.to_sym)
-            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            if @klass.method_defined?(method_name.to_sym)
+              method = @klass.instance_method(method_name.to_sym)
+              T::Private::Methods.maybe_run_sig_block_for_method(method)
+            end
             super(method_name)
           end
         end
@@ -36,7 +38,7 @@ if defined? ::RSpec::Mocks
 
         module MethodDoubleExtensions
           def initialize(object, method_name, proxy)
-            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true)
+            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true) # rubocop:disable Performance/BindCall
               method = ::RSpec::Support.method_handle_for(object, method_name)
               T::Private::Methods.maybe_run_sig_block_for_method(method)
             end

data/lib/types/configuration.rb

@@ -451,7 +451,7 @@ module T::Configuration
   @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
     ->(type) {MODULE_NAME.bind_call(type)}
   else
-    ->(type) {MODULE_NAME.bind(type).call}
+    ->(type) {MODULE_NAME.bind(type).call} # rubocop:disable Performance/BindCall
   end
 
   @module_name_mangler = nil

data/lib/types/enum.rb

@@ -357,11 +357,16 @@ 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
 
     raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+
+    # "oj" gem JSON support
+    if Object.const_defined?(:Oj)
+      Object.const_get(:Oj).register_odd(child_class, child_class, :try_deserialize, :serialize)
+    end
   end
 
   # Marshal support

data/lib/types/generic.rb

@@ -19,4 +19,6 @@ module T::Generic
   def type_template(variance=:invariant, &blk)
     T::Types::TypeTemplate.new(variance)
   end
+
+  def has_attached_class!(variance=:invariant, &blk); end
 end

data/lib/types/helpers.rb

@@ -11,6 +11,13 @@ module T::Helpers
   ### Class/Module Helpers ###
 
   def abstract!
+    if defined?(super)
+      # This is to play nicely with Rails' AbstractController::Base,
+      # which also defines an `abstract!` method.
+      # https://api.rubyonrails.org/classes/AbstractController/Base.html#method-c-abstract-21
+      super
+    end
+
     Private::Abstract::Declare.declare_abstract(self, type: :abstract)
   end
 

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

@@ -18,7 +18,6 @@ module T::Private::Abstract::Declare
     Abstract::Data.set(mod, :abstract_type, type)
 
     mod.extend(Abstract::Hooks)
-    mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
       if type == :interface
@@ -27,26 +26,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
+      mod.send(:define_singleton_method, :new) do |*args, &blk|
+        result = super(*args, &blk)
+        if result.instance_of?(mod)
           raise "#{mod} is declared as abstract; it cannot be instantiated"
         end
-        super(*args, &blk)
+        result
       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/caller_utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::CallerUtils
+  if Thread.respond_to?(:each_caller_location) # RUBY_VERSION >= "3.2"
+    def self.find_caller
+      Thread.each_caller_location do |loc|
+        next if loc.path&.start_with?("<internal:")
+
+        return loc if yield(loc)
+      end
+      nil
+    end
+  else
+    def self.find_caller
+      caller_locations(2).find do |loc|
+        !loc.path&.start_with?("<internal:") && yield(loc)
+      end
+    end
+  end
+end

data/lib/types/private/casts.rb

@@ -3,9 +3,12 @@
 
 module T::Private
   module Casts
-    def self.cast(value, type, cast_method:)
+    def self.cast(value, type, cast_method)
       begin
-        error = T::Utils.coerce(type).error_message_for_obj(value)
+        coerced_type = T::Utils::Private.coerce_and_check_module_types(type, value, true)
+        return value unless coerced_type
+
+        error = coerced_type.error_message_for_obj(value)
         return value unless error
 
         caller_loc = T.must(caller_locations(2..2)).first
@@ -22,7 +25,7 @@ module T::Private
     # there's a lot of shared logic with the above one, but factoring
     # it out like this makes it easier to hopefully one day delete
     # this one
-    def self.cast_recursive(value, type, cast_method:)
+    def self.cast_recursive(value, type, cast_method)
       begin
         error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
         return value unless error

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

@@ -3,12 +3,17 @@
 
 module T::Private::Methods
   @installed_hooks = {}
-  @signatures_by_method = {}
-  @sig_wrappers = {}
+  if defined?(Concurrent::Hash)
+    @signatures_by_method = Concurrent::Hash.new
+    @sig_wrappers = Concurrent::Hash.new
+  else
+    @signatures_by_method = {}
+    @sig_wrappers = {}
+  end
   @sigs_that_raised = {}
   # stores method names that were declared final without regard for where.
   # enables early rejection of names that we know can't induce final method violations.
-  @was_ever_final_names = {}
+  @was_ever_final_names = {}.compare_by_identity
   # maps from a module's object_id to the set of final methods declared in that module.
   # we also overload entries slightly: if the value is nil, that means that the
   # module has final methods somewhere along its ancestor chain, but does not itself
@@ -20,7 +25,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}
+  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}.compare_by_identity
   # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
   # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
   # in installed_hooks.
@@ -83,7 +88,7 @@ module T::Private::Methods
       raise "Procs cannot have override/abstract modifiers"
     end
     if decl.mod != PROC_TYPE
-      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block?"
+      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block? Perhaps you wanted the `T.self_type` instead: https://sorbet.org/docs/self-type"
     end
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
@@ -117,6 +122,11 @@ module T::Private::Methods
     @signatures_by_method[key]
   end
 
+  # Fetch the directory name of the file that defines the `T::Private` constant and
+  # add a trailing slash to allow us to match it as a directory prefix.
+  SORBET_RUNTIME_LIB_PATH = File.dirname(T.const_source_location(:Private).first) + File::SEPARATOR
+  private_constant :SORBET_RUNTIME_LIB_PATH
+
   # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
   # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
   # is already a method defined on one of target_ancestors with the same name that is final.
@@ -127,7 +137,7 @@ module T::Private::Methods
     source_ancestors = nil
     # use reverse_each to check farther-up ancestors first, for better error messages.
     target_ancestors.reverse_each do |ancestor|
-      final_methods = @modules_with_final.fetch(ancestor.object_id, nil)
+      final_methods = @modules_with_final.fetch(ancestor, nil)
       # In this case, either ancestor didn't have any final methods anywhere in its
       # ancestor chain, or ancestor did have final methods somewhere in its ancestor
       # chain, but no final methods defined in ancestor itself.  Either way, there
@@ -145,20 +155,20 @@ module T::Private::Methods
             # filter out things without actual final methods just to make sure that
             # the below checks (which should be uncommon) go as quickly as possible.
             source_ancestors.select! do |a|
-              @modules_with_final.fetch(a.object_id, nil)
+              @modules_with_final.fetch(a, nil)
             end
           end
           # final-ness means that there should be no more than one index for which
           # the below block returns true.
           defining_ancestor_idx = source_ancestors.index do |a|
-            @modules_with_final.fetch(a.object_id).include?(method_name)
+            @modules_with_final.fetch(a).include?(method_name)
           end
           next if defining_ancestor_idx && source_ancestors[defining_ancestor_idx] == ancestor
         end
 
         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.match?(%r{sorbet-runtime[^/]*/lib/})}
+        caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.path.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"
@@ -186,13 +196,11 @@ module T::Private::Methods
     end
   end
 
-  def self.add_module_with_final_method(mod, method_name, is_singleton_method)
-    m = is_singleton_method ? mod.singleton_class : mod
-    mid = m.object_id
-    methods = @modules_with_final[mid]
+  def self.add_module_with_final_method(mod, method_name)
+    methods = @modules_with_final[mod]
     if methods.nil?
       methods = {}
-      @modules_with_final[mid] = methods
+      @modules_with_final[mod] = methods
     end
     methods[method_name] = true
     nil
@@ -200,24 +208,23 @@ module T::Private::Methods
 
   def self.note_module_deals_with_final(mod)
     # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod.object_id]
-    @modules_with_final[mod.singleton_class.object_id]
+    @modules_with_final[mod]
+    @modules_with_final[mod.singleton_class]
   end
 
   # Only public because it needs to get called below inside the replace_method blocks below.
-  def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
+  def self._on_method_added(hook_mod, mod, method_name)
     if T::Private::DeclState.current.skip_on_method_added
       return
     end
 
     current_declaration = T::Private::DeclState.current.active_declaration
-    mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
 
     if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.final)
       raise "#{mod} was declared as final but its method `#{method_name}` was not declared as final"
     end
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
-    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod.object_id)
+    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod)
       _check_final_ancestors(mod, mod.ancestors, [method_name], nil)
       # We need to fetch the active declaration again, as _check_final_ancestors
       # may have reset it (see the comment in that method for details).
@@ -247,7 +254,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,
@@ -271,7 +278,7 @@ module T::Private::Methods
         elsif T::Configuration::AT_LEAST_RUBY_2_7
           original_method.bind_call(self, *args, &blk)
         else
-          original_method.bind(self).call(*args, &blk)
+          original_method.bind(self).call(*args, &blk) # rubocop:disable Performance/BindCall
         end
       end
     end
@@ -282,7 +289,7 @@ module T::Private::Methods
       # use hook_mod, not mod, because for example, we want class C to be marked as having final if we def C.foo as
       # final. change this to mod to see some final_method tests fail.
       note_module_deals_with_final(hook_mod)
-      add_module_with_final_method(hook_mod, method_name, is_singleton_method)
+      add_module_with_final_method(mod, method_name)
     end
   end
 
@@ -334,9 +341,11 @@ module T::Private::Methods
         nil
       end
 
+    declaration_block.loc = nil
+
     signature =
       if current_declaration
-        build_sig(hook_mod, method_name, original_method, current_declaration, declaration_block.loc)
+        build_sig(hook_mod, method_name, original_method, current_declaration)
       else
         Signature.new_untyped(method: original_method)
       end
@@ -353,7 +362,7 @@ module T::Private::Methods
       .decl
   end
 
-  def self.build_sig(hook_mod, method_name, original_method, current_declaration, loc)
+  def self.build_sig(hook_mod, method_name, original_method, current_declaration)
     begin
       # We allow `sig` in the current module's context (normal case) and
       if hook_mod != current_declaration.mod &&
@@ -424,7 +433,7 @@ module T::Private::Methods
     run_sig_block_for_key(method_to_key(method))
   end
 
-  private_class_method def self.run_sig_block_for_key(key)
+  private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
       sig = @signatures_by_method[key]
@@ -447,14 +456,17 @@ module T::Private::Methods
     end
 
     @sig_wrappers.delete(key)
+
+    sig.force_type_init if force_type_init
+
     sig
   end
 
-  def self.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
     loop do
       break if @sig_wrappers.empty?
       key, = @sig_wrappers.first
-      run_sig_block_for_key(key)
+      run_sig_block_for_key(key, force_type_init: force_type_init)
     end
   end
 
@@ -467,8 +479,8 @@ module T::Private::Methods
   def self._hook_impl(target, singleton_class, source)
     # we do not need to call add_was_ever_final here, because we have already marked
     # any such methods when source was originally defined.
-    if !@modules_with_final.include?(target.object_id)
-      if !@modules_with_final.include?(source.object_id)
+    if !@modules_with_final.include?(target)
+      if !@modules_with_final.include?(source)
         return
       end
       note_module_deals_with_final(target)
@@ -494,19 +506,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) # rubocop:disable Performance/BindCall
+        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) # rubocop:disable Performance/BindCall
+        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) # rubocop:disable Performance/BindCall
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]
@@ -516,14 +546,14 @@ module T::Private::Methods
   module MethodHooks
     def method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: false)
+      ::T::Private::Methods._on_method_added(self, self, name)
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
+      ::T::Private::Methods._on_method_added(self, singleton_class, name)
     end
   end