sorbet-runtime 0.5.8993 → 0.5.9566

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b153e0e894eb0a81121fd2c9a2f52cccf1654a78b6fc72d75eacc10d6ee288
-  data.tar.gz: c09b72a6a28a96d35e9076b206d9019df999659145842f6c2b5ec7d3481e4850
+  metadata.gz: 1e5023e6be54c34aae9eaa90bd256fc8e9f15b56d54490f21530fb6ebac519fe
+  data.tar.gz: 43e21db8ed3660374e82d0017fcbca9768e3b8ce15ffe85997aa854e2338d47c
 SHA512:
-  metadata.gz: 948194b8718dd728ecaa0668421480103ce052587c6ceebee0ec01818ecf529d0a62715f0c66409ff07594c6ad4c8c0f22a05921129c66cb405f2fe143b46705
-  data.tar.gz: a788eea54fe2321d6060a79ef31ab784b21a6a4e9e15b299600abbe9699e4cc8095eaa69bedbfc07fa5f2a3e3ef959e002562db705050f8882878dbb15b6a14e
+  metadata.gz: c2d2348cd0cf77820a3e3b5a5f935cf9bebc481dd2e85c4af01c642601d95215f3fe00f8c3145ccaf98626d4bc8815013e74b8d4c80c9f6b8159ec6f443e739a
+  data.tar.gz: ff45d3aa7343c2874d369d422b9690342c91c7a1f650229b108fef3bc9f7a92e68a06ca5fe38391a40aa6163a6839e63bc02dbcded7ea26d635338b359b514c5

data/lib/sorbet-runtime.rb

@@ -12,8 +12,6 @@ module T::Private; end
 module T::Private::Abstract; end
 module T::Private::Types; end
 
-require 'set'
-
 # Each section is a group that I believe need a fixed ordering. There is also
 # an ordering between groups.
 
@@ -112,3 +110,6 @@ require_relative 'types/struct'
 require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'
+
+# Sorbet Compiler support module
+require_relative 'types/private/compiler'

data/lib/types/_types.rb

@@ -53,7 +53,8 @@ module T
   end
 
   # Matches any of the listed values
-  def self.enum(values)
+  # @deprecated Use T::Enum instead.
+  def self.deprecated_enum(values)
     T::Types::Enum.new(values)
   end
 
@@ -78,14 +79,13 @@ module T
     T::Types::ClassOf.new(klass)
   end
 
-
   ## END OF THE METHODS TO PASS TO `sig`.
 
-
   # Constructs a type alias. Used to create a short name for a larger type. In Ruby this returns a
   # wrapper that contains a proc that is evaluated to get the underlying type. This syntax however
-  # is needed for support by the static checker. Example usage:
+  # is needed for support by the static checker.
   #
+  # @example
   #  NilableString = T.type_alias {T.nilable(String)}
   #
   #  sig {params(arg: NilableString, default: String).returns(String)}
@@ -108,8 +108,9 @@ module T
   # References a type parameter which was previously defined with
   # `type_parameters`.
   #
-  # This is used for generic methods. Example usage:
+  # This is used for generic methods.
   #
+  # @example
   #  sig
   #  .type_parameters(:U)
   #  .params(
@@ -187,7 +188,7 @@ module T
   # cycle. However, we also don't actually need to do so; An untyped
   # identity method works just as well here.
   #
-  # sig {params(value: T.untyped).returns(T.untyped)}
+  # `sig {params(value: T.untyped).returns(T.untyped)}`
   def self.unsafe(value)
     value
   end
@@ -208,7 +209,7 @@ module T
   # 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)).returns(A)}
+  # `sig {params(arg: T.nilable(A)).returns(A)}`
   def self.must(arg)
     return arg if arg
     return arg if arg == false
@@ -216,7 +217,7 @@ module T
     begin
       raise TypeError.new("Passed `nil` into T.must")
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Configuration.inline_type_error_handler(e)
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must', value: arg, type: nil})
     end
   end
 
@@ -241,7 +242,7 @@ module T
     begin
       raise TypeError.new(msg)
     rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-      T::Configuration.inline_type_error_handler(e)
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.absurd', value: value, type: nil})
     end
   end
 

data/lib/types/configuration.rb

@@ -112,7 +112,7 @@ module T::Configuration
   # statically, so that methods don't have to guard themselves from being
   # called incorrectly by untyped code.
   #
-  # @param [:never, :tests, :always] default_checked_level
+  # @param [:never, :compiled, :tests, :always] default_checked_level
   def self.default_checked_level=(default_checked_level)
     T::Private::RuntimeLevels.default_checked_level = default_checked_level
   end
@@ -130,10 +130,15 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [TypeError] error TypeError that was raised
+  #  @param [TypeError] error TypeError that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :kind One of:
+  #    ['T.cast', 'T.let', 'T.bind', 'T.assert_type!', 'T.must', 'T.absurd']
+  #  @option opts [Object, nil] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
   #
   # @example
-  #   T::Configuration.inline_type_error_handler = lambda do |error|
+  #   T::Configuration.inline_type_error_handler = lambda do |error, opts|
   #     puts error.message
   #   end
   def self.inline_type_error_handler=(value)
@@ -141,15 +146,20 @@ module T::Configuration
     @inline_type_error_handler = value
   end
 
-  private_class_method def self.inline_type_error_handler_default(error)
+  private_class_method def self.inline_type_error_handler_default(error, opts)
     raise error
   end
 
-  def self.inline_type_error_handler(error)
+  def self.inline_type_error_handler(error, opts={})
     if @inline_type_error_handler
-      @inline_type_error_handler.call(error)
+      # Backwards compatibility before `inline_type_error_handler` took a second arg
+      if @inline_type_error_handler.arity == 1
+        @inline_type_error_handler.call(error)
+      else
+        @inline_type_error_handler.call(error, opts)
+      end
     else
-      inline_type_error_handler_default(error)
+      inline_type_error_handler_default(error, opts)
     end
     nil
   end
@@ -169,8 +179,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [StandardError] error The error that was raised
-  # @param [Thread::Backtrace::Location] location Location of the error
+  #  @param [StandardError] error The error that was raised
+  #  @param [Thread::Backtrace::Location] location Location of the error
   #
   # @example
   #   T::Configuration.sig_builder_error_handler = lambda do |error, location|
@@ -211,16 +221,16 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [StandardError] error The error that was raised
-  # @param [Hash] opts A hash containing contextual information on the error:
-  # @option opts [Method, UnboundMethod] :method Method on which the signature build failed
-  # @option opts [T::Private::Methods::Declaration] :declaration Method
-  #   signature declaration struct
-  # @option opts [T::Private::Methods::Signature, nil] :signature Signature
-  #   that failed (nil if sig build failed before Signature initialization)
-  # @option opts [T::Private::Methods::Signature, nil] :super_signature Super
-  #   method's signature (nil if method is not an override or super method
-  #   does not have a method signature)
+  #  @param [StandardError] error The error that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [Method, UnboundMethod] :method Method on which the signature build failed
+  #  @option opts [T::Private::Methods::Declaration] :declaration Method
+  #    signature declaration struct
+  #  @option opts [T::Private::Methods::Signature, nil] :signature Signature
+  #    that failed (nil if sig build failed before Signature initialization)
+  #  @option opts [T::Private::Methods::Signature, nil] :super_signature Super
+  #    method's signature (nil if method is not an override or super method
+  #    does not have a method signature)
   #
   # @example
   #   T::Configuration.sig_validation_error_handler = lambda do |error, opts|
@@ -256,17 +266,17 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [T::Private::Methods::Signature] signature Signature that failed
-  # @param [Hash] opts A hash containing contextual information on the error:
-  # @option opts [String] :message Error message
-  # @option opts [String] :kind One of:
-  #   ['Parameter', 'Block parameter', 'Return value']
-  # @option opts [Symbol] :name Param or block param name (nil for return
-  #   value)
-  # @option opts [Object] :type Expected param/return value type
-  # @option opts [Object] :value Actual param/return value
-  # @option opts [Thread::Backtrace::Location] :location Location of the
-  #   caller
+  #  @param [T::Private::Methods::Signature] signature Signature that failed
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :message Error message
+  #  @option opts [String] :kind One of:
+  #    ['Parameter', 'Block parameter', 'Return value']
+  #  @option opts [Symbol] :name Param or block param name (nil for return
+  #    value)
+  #  @option opts [Object] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
+  #  @option opts [Thread::Backtrace::Location] :location Location of the
+  #    caller
   #
   # @example
   #   T::Configuration.call_validation_error_handler = lambda do |signature, opts|
@@ -297,8 +307,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Message to be logged
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
+  #  @param [String] str Message to be logged
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
   #
   # @example
   #   T::Configuration.log_info_handler = lambda do |str, extra|
@@ -331,8 +341,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Assertion message
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
   #
   # @example
   #   T::Configuration.soft_assert_handler = lambda do |str, extra|
@@ -365,8 +375,8 @@ module T::Configuration
   #
   # Parameters passed to value.call:
   #
-  # @param [String] str Assertion message
-  # @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
   #
   # @example
   #   T::Configuration.hard_assert_handler = lambda do |str, extra|
@@ -392,7 +402,7 @@ module T::Configuration
   # Set a list of class strings that are to be considered scalar.
   #   (pass nil to reset to default behavior)
   #
-  # @param [String] value Class name.
+  # @param [String] values Class name.
   #
   # @example
   #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
@@ -405,21 +415,21 @@ module T::Configuration
         raise ArgumentError.new("Provided values must all be class name strings.")
       end
 
-      @scalar_types = Set.new(values).freeze
+      @scalar_types = values.each_with_object({}) {|x, acc| acc[x] = true}.freeze
     end
   end
 
-  @default_scalar_types = Set.new(%w[
-    NilClass
-    TrueClass
-    FalseClass
-    Integer
-    Float
-    String
-    Symbol
-    Time
-    T::Enum
-  ]).freeze
+  @default_scalar_types = {
+    "NilClass" => true,
+    "TrueClass" => true,
+    "FalseClass" => true,
+    "Integer" => true,
+    "Float" => true,
+    "String" => true,
+    "Symbol" => true,
+    "Time" => true,
+    "T::Enum" => true,
+  }.freeze
 
   def self.scalar_types
     @scalar_types || @default_scalar_types
@@ -429,10 +439,10 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  if T::Configuration::AT_LEAST_RUBY_2_7
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind_call(type)}
+  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
+    ->(type) {MODULE_NAME.bind_call(type)}
   else
-    @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+    ->(type) {MODULE_NAME.bind(type).call}
   end
 
   @module_name_mangler = nil
@@ -445,7 +455,7 @@ module T::Configuration
   #   to names in generated code. Used by the runtime implementation
   #   associated with `--stripe-packages` mode.
   #
-  # @param [Lambda, Proc, nil] value Proc that converts a type (Class/Module)
+  # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
   #   to a String (pass nil to reset to default behavior)
   def self.module_name_mangler=(handler)
     @module_name_mangler = handler
@@ -454,7 +464,7 @@ module T::Configuration
   # Set to a PII handler function. This will be called with the `sensitivity:`
   # annotations on things that use `T::Props` and can modify them ahead-of-time.
   #
-  # @param [Lambda, Proc, nil] value Proc that takes a hash mapping symbols to the
+  # @param [Lambda, Proc, nil] handler Proc that takes a hash mapping symbols to the
   # prop values. Pass nil to avoid changing `sensitivity:` annotations.
   def self.normalize_sensitivity_and_pii_handler=(handler)
     @sensitivity_and_pii_handler = handler
@@ -470,7 +480,7 @@ module T::Configuration
   # `nil` and will raise an exception when the redacted version of a prop is
   # accessed.
   #
-  # @param [Lambda, Proc, nil] value Proc that converts a value into its
+  # @param [Lambda, Proc, nil] handler Proc that converts a value into its
   # redacted version according to the spec passed as the second argument.
   def self.redaction_handler=(handler)
     @redaction_handler = handler
@@ -483,7 +493,7 @@ module T::Configuration
   # Set to a function which can get the 'owner' of a class. This is
   # used in reporting deserialization errors
   #
-  # @param [Lambda, Proc, nil] value Proc that takes a class and
+  # @param [Lambda, Proc, nil] handler Proc that takes a class and
   # produces its owner, or `nil` if it does not have one.
   def self.class_owner_finder=(handler)
     @class_owner_finder = handler
@@ -523,6 +533,16 @@ module T::Configuration
     @legacy_t_enum_migration_mode || false
   end
 
+  @prop_freeze_handler = ->(instance, prop_name) {}
+
+  def self.prop_freeze_handler=(handler)
+    @prop_freeze_handler = handler
+  end
+
+  def self.prop_freeze_handler
+    @prop_freeze_handler
+  end
+
   # @param [Array] sealed_violation_whitelist An array of Regexp to validate
   #   whether inheriting /including a sealed module outside the defining module
   #   should be allowed. Useful to whitelist benign violations, like shim files

data/lib/types/enum.rb

@@ -47,7 +47,7 @@ class T::Enum
   SerializedVal = T.type_alias {T.untyped}
   private_constant :SerializedVal
 
-  ## Enum class methods ##
+  ### Enum class methods ###
   sig {returns(T::Array[T.attached_class])}
   def self.values
     if @values.nil?
@@ -134,9 +134,7 @@ class T::Enum
     self.from_serialized(mongo_value)
   end
 
-
-  ## Enum instance methods ##
-
+  ### Enum instance methods ###
 
   sig {returns(T.self_type)}
   def dup
@@ -180,7 +178,6 @@ class T::Enum
     end
   end
 
-
   # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
   # values are compared directly against string values.
   #
@@ -246,9 +243,7 @@ class T::Enum
     )
   end
 
-
-  ## Private implementation ##
-
+  ### Private implementation ###
 
   sig {params(serialized_val: SerializedVal).void}
   def initialize(serialized_val=nil)
@@ -366,6 +361,6 @@ class T::Enum
 
   sig {params(args: String).returns(T.attached_class)}
   def self._load(args)
-    deserialize(Marshal.load(args))
+    deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
   end
 end

data/lib/types/helpers.rb

@@ -4,6 +4,8 @@
 # Use as a mixin with extend (`extend T::Helpers`).
 # Docs at https://confluence.corp.stripe.com/display/PRODINFRA/Ruby+Types
 module T::Helpers
+  extend T::Sig
+
   Private = T::Private
 
   ### Class/Module Helpers ###
@@ -44,7 +46,7 @@ module T::Helpers
   #   module MyHelper
   #     extend T::Helpers
   #
-  #     requires_ancestor Kernel
+  #     requires_ancestor { Kernel }
   #   end
   #
   #   class MyClass < BasicObject # error: `MyClass` must include `Kernel` (required by `MyHelper`)
@@ -52,5 +54,5 @@ module T::Helpers
   #   end
   #
   # TODO: implement the checks in sorbet-runtime.
-  def requires_ancestor(mod, *mods); end
+  def requires_ancestor(&block); end
 end

data/lib/types/non_forcing_constants.rb

@@ -2,11 +2,6 @@
 # typed: strict
 
 module T::NonForcingConstants
-  T::Sig::WithoutRuntime.sig {returns(T::Boolean)}
-  private_class_method def self.stripe_packages_enabled?
-    const_defined?('StripePackages') && const_get('StripePackages').enabled?
-  end
-
   # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
   # shows up in the hover/completion documentation via LSP.
   T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
@@ -16,10 +11,11 @@ module T::NonForcingConstants
       raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
     end
 
-    # TODO(gdritter): this might not be want we want in a multipackage
-    # world; revisit this implementation we move on from the monopackage
-    if stripe_packages_enabled?
-      klass = "PkgRegistry::#{package}::#{klass}"
+    # We don't treat packages differently at runtime, but the static
+    # type-checker still needs to have the package and constant
+    # separated out. This just re-assembles the string as needed
+    if !package.nil?
+      klass = "::#{package}::#{klass}"
     end
 
     current_klass = T.let(nil, T.nilable(Module))

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

@@ -40,6 +40,11 @@ module T::Private::Abstract::Declare
         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)
+
       if mod.respond_to?(:ruby2_keywords, true)
         mod.send(:ruby2_keywords, :initialize)
       end

data/lib/types/private/casts.rb

@@ -2,14 +2,6 @@
 # typed: false
 
 module T::Private
-  # Dynamically confirm that `value` is recursively a valid value of
-  # type `type`, including recursively through collections. Note that
-  # in some cases this runtime check can be very expensive, especially
-  # with large collections of objects.
-  def self.check_type_recursive!(value, type)
-    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
-  end
-
   module Casts
     def self.cast(value, type, cast_method:)
       begin
@@ -22,7 +14,7 @@ module T::Private
 
         raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
       rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-        T::Configuration.inline_type_error_handler(e)
+        T::Configuration.inline_type_error_handler(e, {kind: cast_method, value: value, type: type})
         value
       end
     end
@@ -41,7 +33,7 @@ module T::Private
 
         raise TypeError.new("#{cast_method}: #{error}\n#{suffix}")
       rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
-        T::Configuration.inline_type_error_handler(e)
+        T::Configuration.inline_type_error_handler(e, {kind: cast_method, value: value, type: type})
         value
       end
     end

data/lib/types/private/compiler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private
+  module Compiler
+    # If this code ever runs, the caller is running interpreted (or the
+    # compiler didn't see the call to `running_compiled?` statically.)
+    #
+    # The Sorbet Compiler replaces calls to this method unconditionally (no
+    # runtime guards) to return `true` when compiling a file.
+    def self.running_compiled?
+      false
+    end
+
+    # Returns `nil` because the compiler isn't running.
+    #
+    # The Sorbet Compiler replaces calls to this method unconditionally (no
+    # runtime guards) to return a String showing the Sorbet Compiler's version
+    # string.
+    def self.compiler_version
+      nil
+    end
+  end
+end

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

@@ -2,14 +2,14 @@
 # typed: false
 
 module T::Private::Methods
-  @installed_hooks = Set.new
+  @installed_hooks = {}
   @signatures_by_method = {}
   @sig_wrappers = {}
   @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 = Set.new
-  # maps from modules to the set of final methods declared in that module.
+  @was_ever_final_names = {}
+  # 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
   # have any final methods.
@@ -20,7 +20,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}
   # 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.
@@ -127,7 +127,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, nil)
+      final_methods = @modules_with_final.fetch(ancestor.object_id, 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 +145,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, nil)
+              @modules_with_final.fetch(a.object_id, 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).include?(method_name)
+            @modules_with_final.fetch(a.object_id).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 = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/})}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -188,18 +188,20 @@ module T::Private::Methods
 
   def self.add_module_with_final_method(mod, method_name, is_singleton_method)
     m = is_singleton_method ? mod.singleton_class : mod
-    methods = @modules_with_final[m]
+    mid = m.object_id
+    methods = @modules_with_final[mid]
     if methods.nil?
-      methods = Set.new
-      @modules_with_final[m] = methods
+      methods = {}
+      @modules_with_final[mid] = methods
     end
-    methods.add(method_name)
+    methods[method_name] = true
+    nil
   end
 
   def self.note_module_deals_with_final(mod)
     # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod]
-    @modules_with_final[mod.singleton_class]
+    @modules_with_final[mod.object_id]
+    @modules_with_final[mod.singleton_class.object_id]
   end
 
   # Only public because it needs to get called below inside the replace_method blocks below.
@@ -215,7 +217,7 @@ module T::Private::Methods
       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)
+    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod.object_id)
       _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).
@@ -276,7 +278,7 @@ module T::Private::Methods
 
     @sig_wrappers[key] = sig_block
     if current_declaration.final
-      @was_ever_final_names.add(method_name)
+      @was_ever_final_names[method_name] = true
       # 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)
@@ -456,13 +458,17 @@ module T::Private::Methods
     end
   end
 
+  def self.all_checked_tests_sigs
+    @signatures_by_method.values.select {|sig| sig.check_level == :tests}
+  end
+
   # the module target is adding the methods from the module source to itself. we need to check that for all instance
   # methods M on source, M is not defined on any of target's ancestors.
   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)
-      if !@modules_with_final.include?(source)
+    if !@modules_with_final.include?(target.object_id)
+      if !@modules_with_final.include?(source.object_id)
         return
       end
       note_module_deals_with_final(target)
@@ -523,7 +529,7 @@ module T::Private::Methods
 
   def self.install_hooks(mod)
     return if @installed_hooks.include?(mod)
-    @installed_hooks << mod
+    @installed_hooks[mod] = true
 
     if mod == TOP_SELF
       # self at the top-level of a file is weirdly special in Ruby