sorbet-runtime 0.5.9103 → 0.5.9368

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd50aa97fa3835f75f05ddad407ced4062053e791cb9c246a4ac617cb6e4eeb5
-  data.tar.gz: dd7a5031c72ae5ce3a09324d2b110c343e1409e350c12b1a8bf8a1bf21763c90
+  metadata.gz: c091500cbf7054e5603c1258b3295f49f151b0d40e5353d2f904d520f5f98da0
+  data.tar.gz: 61a637921e738a248610afe0a6281af23cbef7f337e01db379583c32c837eee1
 SHA512:
-  metadata.gz: fa6efdc3b42d1b42322af825df44bf33c625cc24b2d93f5474887218f686604e8603db6c19afae00c29c6e32e1e1ecceb52a07de68471ec9cf18aea01ab98ef4
-  data.tar.gz: a16780c9665e17e0666d2e2b04a5b60a04a7b02863f111d3a068e2b5c7b32b72334b246b00e76ddfa98d1a64fd78c79fa1467e03d19d80203c0bc5ccacf28b6c
+  metadata.gz: ab2e881510a729c50a1f75ae6326ed206c371233d9e61c43f479969889c47d2a93550ce6dc8b7dd84c5ebe87e622848074d41d31397cd690113aa353544cb6c8
+  data.tar.gz: 5f4c1f1a8dacfc9c1e987a6124acea43d52ccf8ef8999eec0d35cf3c126f588cf2dc2ae1c58b1ef0c513a9b8b7b2c97fbd34cf11870d5a516735551abbb8e0c3

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.
 
@@ -24,6 +22,8 @@ require_relative 'types/private/decl_state'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
+require_relative 'types/private/methods/modes'
+require_relative 'types/private/methods/decl_builder'
 require_relative 'types/sig'
 require_relative 'types/helpers'
 require_relative 'types/private/final'
@@ -62,7 +62,6 @@ require_relative 'types/types/type_member'
 require_relative 'types/types/type_template'
 
 # Call validation
-require_relative 'types/private/methods/modes'
 require_relative 'types/private/methods/call_validation'
 
 # Signature validation
@@ -76,7 +75,6 @@ require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
-require_relative 'types/private/methods/decl_builder'
 require_relative 'types/private/methods/signature'
 require_relative 'types/private/retry'
 require_relative 'types/utils'

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
 
@@ -82,8 +83,9 @@ module T
 
   # 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)}
@@ -106,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(
@@ -185,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
@@ -206,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
@@ -214,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
 
@@ -239,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

@@ -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
@@ -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

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,7 +134,7 @@ class T::Enum
     self.from_serialized(mongo_value)
   end
 
-  ## Enum instance methods ##
+  ### Enum instance methods ###
 
   sig {returns(T.self_type)}
   def dup
@@ -243,7 +243,7 @@ class T::Enum
     )
   end
 
-  ## Private implementation ##
+  ### Private implementation ###
 
   sig {params(serialized_val: SerializedVal).void}
   def initialize(serialized_val=nil)

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

@@ -14,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
@@ -33,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/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.
@@ -29,12 +29,13 @@ module T::Private::Methods
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
-  DeclarationBlock = Struct.new(:mod, :loc, :blk, :final, :raw)
+  DeclarationBlock = Struct.new(:mod, :loc, :blk, :raw, :decl_builder)
 
   def self.declare_sig(mod, loc, arg, &blk)
-    T::Private::DeclState.current.active_declaration = _declare_sig_internal(mod, loc, arg, &blk)
+    declaration = _declare_sig_internal(mod, loc, arg, &blk)
+    T::Private::DeclState.current.active_declaration = declaration
 
-    nil
+    declaration.decl_builder
   end
 
   # See tests for how to use this.  But you shouldn't be using this.
@@ -54,7 +55,10 @@ module T::Private::Methods
       raise "Invalid argument to `sig`: #{arg}"
     end
 
-    DeclarationBlock.new(mod, loc, blk, arg == :final, raw)
+    decl_builder = DeclBuilder.new(mod, raw)
+    decl_builder.final if arg == :final # needed for backwards compatibility with sig(:final) {...}
+
+    DeclarationBlock.new(mod, loc, blk, raw, decl_builder)
   end
 
   def self._with_declared_signature(mod, declblock, &blk)
@@ -127,7 +131,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,13 +149,13 @@ 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
@@ -188,18 +192,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.
@@ -211,11 +217,11 @@ module T::Private::Methods
     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)
+    if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.decl_builder.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)
+    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).
@@ -275,8 +281,8 @@ module T::Private::Methods
     end
 
     @sig_wrappers[key] = sig_block
-    if current_declaration.final
-      @was_ever_final_names.add(method_name)
+    if current_declaration.decl_builder.final?
+      @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)
@@ -344,10 +350,9 @@ module T::Private::Methods
   end
 
   def self.run_builder(declaration_block)
-    builder = DeclBuilder.new(declaration_block.mod, declaration_block.raw)
-    builder
-      .instance_exec(&declaration_block.blk)
-      .finalize!
+    declaration_block
+      .decl_builder
+      .run!(&declaration_block.blk)
       .decl
   end
 
@@ -465,8 +470,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)
-      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)
@@ -527,7 +532,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