sorbet-runtime 0.5.5794 → 0.5.6539

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9a48252c9529d0ca91f96108b141c85388c88180281e5c8a682b16c11a9d5a
-  data.tar.gz: 31dc95eabc00327b1672a8fc142da7dc47f0ee0699fd4112358042248628675b
+  metadata.gz: 3594dc0c726d2a7189c7544226a6ced4240f4a6df2c18bdae635cc30bb223e7b
+  data.tar.gz: dae60008d7f685ecdf231edefdf0b01b595c597c6ae646e7ba7070eada079fa2
 SHA512:
-  metadata.gz: 21b1ef4ffdd76365effafe0c6a3eea4b15c1f9c36f2f402a1c8ba382d2f03d89f2202c1b8ac2aa82c315c7471f0989f7501d1888a49f67d401d33d26ac8e4d3a
-  data.tar.gz: 0f4c110725910ae452ea72fe6852538aa1c31cbb576dc242fe3631bd318e3b2bfda7b0fe3b05362584bd53885c9788a4f3eb2d5920d285c1c39ce727fb0ebd14
+  metadata.gz: 519bf1b1c4f04792d88c817a9bb3a213b01e783a96597e1e328a8a5c9736e78ff7a0a93ef31d56787fd9468d09980e4670edffcd71f59ff299cc7a09a80a714b
+  data.tar.gz: 0150d316fb26d07fd0693d3b948dfaa6fe1979053dc12f9811c5c9c6d29b711affaa3e6be16a34a08fd6abf5a1db816b4872b7b655895353cdf65094f7e0ad5c

data/lib/sorbet-runtime.rb

@@ -19,10 +19,8 @@ require 'set'
 
 # These are pre-reqs for almost everything in here.
 require_relative 'types/configuration'
-require_relative 'types/profile'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
-require_relative 'types/runtime_profiled'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'

data/lib/types/_types.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # typed: true
 # This is where we define the shortcuts, so we can't use them here
-# rubocop:disable PrisonGuard/UseOpusTypesShortcut
 
 #  _____
 # |_   _|   _ _ __   ___  ___
@@ -26,23 +25,26 @@
 module T
   # T.any(<Type>, <Type>, ...) -- matches any of the types listed
   def self.any(type_a, type_b, *types)
-    T::Types::Union.new([type_a, type_b] + types)
+    type_a = T::Utils.coerce(type_a)
+    type_b = T::Utils.coerce(type_b)
+    types = types.map {|t| T::Utils.coerce(t)} if !types.empty?
+    T::Types::Union::Private::Pool.union_of_types(type_a, type_b, types)
   end
 
   # Shorthand for T.any(type, NilClass)
   def self.nilable(type)
-    T::Types::Union.new([type, NilClass])
+    T::Types::Union::Private::Pool.union_of_types(T::Utils.coerce(type), T::Utils::Nilable::NIL_TYPE)
   end
 
   # Matches any object. In the static checker, T.untyped allows any
   # method calls or operations.
   def self.untyped
-    T::Types::Untyped.new
+    T::Types::Untyped::Private::INSTANCE
   end
 
   # Indicates a function never returns (e.g. "Kernel#raise")
   def self.noreturn
-    T::Types::NoReturn.new
+    T::Types::NoReturn::Private::INSTANCE
   end
 
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
@@ -62,12 +64,12 @@ module T
 
   # Matches `self`:
   def self.self_type
-    T::Types::SelfType.new
+    T::Types::SelfType::Private::INSTANCE
   end
 
   # Matches the instance type in a singleton-class context
   def self.attached_class
-    T::Types::AttachedClassType.new
+    T::Types::AttachedClassType::Private::INSTANCE
   end
 
   # Matches any class that subclasses or includes the provided class
@@ -145,6 +147,25 @@ module T
     Private::Casts.cast(value, type, cast_method: "T.let")
   end
 
+  # Tells the type checker to treat `self` in the current block as `type`.
+  # Useful for blocks that are captured and executed later with instance_exec.
+  # Use like:
+  #
+  #  seconds = lambda do
+  #    T.bind(self, NewBinding)
+  #    ...
+  #  end
+  #
+  # `T.bind` behaves like `T.cast` in that it is assumed to be true statically.
+  #
+  # If `checked` is true, raises an exception at runtime if the value
+  # doesn't match the type (this is the default).
+  def self.bind(value, type, checked: true)
+    return value unless checked
+
+    Private::Casts.cast(value, type, cast_method: "T.bind")
+  end
+
   # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
   # fail). Use this for debugging typechecking errors, or to ensure that type information is
   # statically known and being checked appropriately. If `checked` is true, raises an exception at
@@ -282,4 +303,3 @@ module T
     end
   end
 end
-# rubocop:enable PrisonGuard/UseOpusTypesShortcut

data/lib/types/compatibility_patches.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 # typed: ignore
 
-require_relative 'private/methods/_methods'
-
 # Work around an interaction bug with sorbet-runtime and rspec-mocks,
 # which occurs when using message expectations (*_any_instance_of,
 # expect, allow) and and_call_original.

data/lib/types/configuration.rb

@@ -2,6 +2,9 @@
 # frozen_string_literal: true
 
 module T::Configuration
+  # Cache this comparisonn to avoid two allocations all over the place.
+  AT_LEAST_RUBY_2_7 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
+
   # Announces to Sorbet that we are currently in a test environment, so it
   # should treat any sigs which are marked `.checked(:tests)` as if they were
   # just a normal sig.
@@ -42,6 +45,65 @@ module T::Configuration
     T::Private::Methods.set_final_checks_on_hooks(false)
   end
 
+  @include_value_in_type_errors = true
+  # Whether to include values in TypeError messages.
+  #
+  # Including values is useful for debugging, but can potentially leak
+  # sensitive information to logs.
+  #
+  # @return [T::Boolean]
+  def self.include_value_in_type_errors?
+    @include_value_in_type_errors
+  end
+
+  # Configure if type errors excludes the value of the problematic type.
+  #
+  # The default is to include values in type errors:
+  #   TypeError: Expected type Integer, got String with value "foo"
+  #
+  # When values are excluded from type errors:
+  #   TypeError: Expected type Integer, got String
+  def self.exclude_value_in_type_errors
+    @include_value_in_type_errors = false
+  end
+
+  # Opposite of exclude_value_in_type_errors.
+  # (Including values in type errors is the default)
+  def self.include_value_in_type_errors
+    @include_value_in_type_errors = true
+  end
+
+  # Whether VM-defined prop serialization/deserialization routines can be enabled.
+  #
+  # @return [T::Boolean]
+  def self.can_enable_vm_prop_serde?
+    T::Props::Private::DeserializerGenerator.respond_to?(:generate2)
+  end
+
+  # Whether to use VM-defined prop serialization/deserialization routines.
+  #
+  # The default is to use runtime codegen inside sorbet-runtime itself.
+  #
+  # @return [T::Boolean]
+  def self.use_vm_prop_serde?
+    @use_vm_prop_serde || false
+  end
+
+  # Enable using VM-defined prop serialization/deserialization routines.
+  #
+  # This method is likely to break things outside of Stripe's systems.
+  def self.enable_vm_prop_serde
+    if !can_enable_vm_prop_serde?
+      hard_assert_handler('Ruby VM is not setup to use VM-defined prop serde')
+    end
+    @use_vm_prop_serde = true
+  end
+
+  # Disable using VM-defined prop serialization/deserialization routines.
+  def self.disable_vm_prop_serde
+    @use_vm_prop_serde = false
+  end
+
   # Configure the default checked level for a sig with no explicit `.checked`
   # builder. When unset, the default checked level is `:always`.
   #
@@ -248,7 +310,7 @@ module T::Configuration
   end
 
   private_class_method def self.log_info_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.log_info_handler(str, extra)
@@ -282,7 +344,7 @@ module T::Configuration
   end
 
   private_class_method def self.soft_assert_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts
+    puts "#{str}, extra: #{extra}"
   end
 
   def self.soft_assert_handler(str, extra)
@@ -338,7 +400,7 @@ module T::Configuration
     if values.nil?
       @scalar_types = values
     else
-      bad_values = values.select {|v| v.class != String}
+      bad_values = values.reject {|v| v.class == String}
       unless bad_values.empty?
         raise ArgumentError.new("Provided values must all be class name strings.")
       end
@@ -347,7 +409,7 @@ module T::Configuration
     end
   end
 
-  @default_scalar_types = Set.new(%w{
+  @default_scalar_types = Set.new(%w[
     NilClass
     TrueClass
     FalseClass
@@ -357,12 +419,80 @@ module T::Configuration
     Symbol
     Time
     T::Enum
-  }).freeze
+  ]).freeze
 
   def self.scalar_types
     @scalar_types || @default_scalar_types
   end
 
+  # Guard against overrides of `name` or `to_s`
+  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)}
+  else
+    @default_module_name_mangler = ->(type) {MODULE_NAME.bind(type).call}
+  end
+
+  @module_name_mangler = nil
+
+  def self.module_name_mangler
+    @module_name_mangler || @default_module_name_mangler
+  end
+
+  # Set to override the default behavior for converting types
+  #   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)
+  #   to a String (pass nil to reset to default behavior)
+  def self.module_name_mangler=(handler)
+    @module_name_mangler = handler
+  end
+
+  # 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
+  # prop values. Pass nil to avoid changing `sensitivity:` annotations.
+  def self.normalize_sensitivity_and_pii_handler=(handler)
+    @sensitivity_and_pii_handler = handler
+  end
+
+  def self.normalize_sensitivity_and_pii_handler
+    @sensitivity_and_pii_handler
+  end
+
+  @redaction_handler = nil
+  # Set to a redaction handling function. This will be called when the
+  # `_redacted` version of a prop reader is used. By default this is set to
+  # `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
+  # redacted version according to the spec passed as the second argument.
+  def self.redaction_handler=(handler)
+    @redaction_handler = handler
+  end
+
+  def self.redaction_handler
+    @redaction_handler
+  end
+
+  # 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
+  # produces its owner, or `nil` if it does not have one.
+  def self.class_owner_finder=(handler)
+    @class_owner_finder = handler
+  end
+
+  def self.class_owner_finder
+    @class_owner_finder
+  end
+
   # Temporarily disable ruby warnings while executing the given block. This is
   # useful when doing something that would normally cause a warning to be
   # emitted in Ruby verbose mode ($VERBOSE = true).
@@ -398,7 +528,7 @@ module T::Configuration
   #   should be allowed. Useful to whitelist benign violations, like shim files
   #   generated for an autoloader.
   def self.sealed_violation_whitelist=(sealed_violation_whitelist)
-    if @sealed_violation_whitelist != nil
+    if !@sealed_violation_whitelist.nil?
       raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
     end
 

data/lib/types/enum.rb

@@ -57,6 +57,17 @@ class T::Enum
     @values
   end
 
+  # This exists for compatibility with the interface of `Hash` & mostly to support
+  # the HashEachMethods Rubocop.
+  sig {params(blk: T.nilable(T.proc.params(arg0: T.attached_class).void)).returns(T.any(T::Enumerator[T.attached_class], T::Array[T.attached_class]))}
+  def self.each_value(&blk)
+    if blk
+      values.each(&blk)
+    else
+      values.each
+    end
+  end
+
   # Convert from serialized value to enum instance
   #
   # Note: It would have been nice to make this method final before people started overriding it.
@@ -88,7 +99,7 @@ class T::Enum
 
   # Note: It would have been nice to make this method final before people started overriding it.
   # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean)}
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean).checked(:never)}
   def self.has_serialized?(serialized_val)
     if @mapping.nil?
       raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
@@ -240,7 +251,7 @@ class T::Enum
 
 
   sig {params(serialized_val: SerializedVal).void}
-  private def initialize(serialized_val=nil)
+  def initialize(serialized_val=nil)
     raise 'T::Enum is abstract' if self.class == T::Enum
     if !self.class.started_initializing?
       raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
@@ -346,4 +357,15 @@ class T::Enum
 
     raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
   end
+
+  # Marshal support
+  sig {params(_level: Integer).returns(String)}
+  def _dump(_level)
+    Marshal.dump(serialize)
+  end
+
+  sig {params(args: String).returns(T.attached_class)}
+  def self._load(args)
+    deserialize(Marshal.load(args))
+  end
 end

data/lib/types/generic.rb

@@ -2,7 +2,6 @@
 # typed: true
 
 # Use as a mixin with extend (`extend T::Generic`).
-# Docs at https://hackpad.corp.stripe.com/Type-Validation-in-pay-server-1JaoTHir5Mo.
 module T::Generic
   include T::Helpers
   include Kernel
@@ -14,10 +13,10 @@ module T::Generic
   end
 
   def type_member(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeMember.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeMember.new(variance)
   end
 
   def type_template(variance=:invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
-    T::Types::TypeTemplate.new(variance) # rubocop:disable PrisonGuard/UseOpusTypesShortcut
+    T::Types::TypeTemplate.new(variance)
   end
 end

data/lib/types/helpers.rb

@@ -33,7 +33,24 @@ module T::Helpers
   #  end
   #
   # Except that it is statically analyzed by sorbet.
-  def mixes_in_class_methods(mod)
-    Private::Mixins.declare_mixes_in_class_methods(self, mod)
+  def mixes_in_class_methods(mod, *mods)
+    Private::Mixins.declare_mixes_in_class_methods(self, [mod].concat(mods))
   end
+
+  # Specify an inclusion or inheritance requirement for `self`.
+  #
+  # Example:
+  #
+  #   module MyHelper
+  #     extend T::Helpers
+  #
+  #     requires_ancestor Kernel
+  #   end
+  #
+  #   class MyClass < BasicObject # error: `MyClass` must include `Kernel` (required by `MyHelper`)
+  #     include MyHelper
+  #   end
+  #
+  # TODO: implement the checks in sorbet-runtime.
+  def requires_ancestor(mod, *mods); end
 end

data/lib/types/interface_wrapper.rb

@@ -83,11 +83,11 @@ class T::InterfaceWrapper
     end
   end
 
-  def kind_of?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def kind_of?(other)
     is_a?(other)
   end
 
-  def is_a?(other) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+  def is_a?(other)
     if !other.is_a?(Module)
       raise TypeError.new("class or module required")
     end
@@ -99,13 +99,13 @@ class T::InterfaceWrapper
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE
+  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
     @target_obj
   end
 
   # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
   # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE
+  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
     @interface_mod
   end
 

data/lib/types/non_forcing_constants.rb

@@ -2,15 +2,26 @@
 # 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).returns(T::Boolean)}
-  def self.non_forcing_is_a?(val, klass)
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass, package: nil)
     method_name = "T::NonForcingConstants.non_forcing_is_a?"
     if klass.empty?
       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}"
+    end
+
     current_klass = T.let(nil, T.nilable(Module))
     current_prefix = T.let(nil, T.nilable(String))
 
@@ -18,34 +29,41 @@ module T::NonForcingConstants
     parts.each do |part|
       if current_klass.nil?
         # First iteration
-        if part != ""
+        if part != "" && package.nil?
+          # if we've supplied a package, we're probably running in
+          # package mode, which means absolute references are
+          # meaningless
           raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
         end
 
         current_klass = Object
         current_prefix = ''
-      else
-        if current_klass.autoload?(part)
-          # There's an autoload registered for that constant, which means it's not
-          # yet loaded. `value` can't be an instance of something not yet loaded.
-          return false
-        end
 
-        # Sorbet guarantees that the string is an absolutely resolved name.
-        search_inheritance_chain = false
-        if !current_klass.const_defined?(part, search_inheritance_chain)
-          return false
-        end
+        # if this had a :: prefix, then there's no more loading to
+        # do---skip to the next one
+        next if part == ""
+      end
 
-        current_klass = current_klass.const_get(part)
-        current_prefix = "#{current_prefix}::#{part}"
+      if current_klass.autoload?(part)
+        # There's an autoload registered for that constant, which means it's not
+        # yet loaded. `value` can't be an instance of something not yet loaded.
+        return false
+      end
 
-        if !Module.===(current_klass)
-          raise ArgumentError.new("#{current_prefix} is not a class or module")
-        end
+      # Sorbet guarantees that the string is an absolutely resolved name.
+      search_inheritance_chain = false
+      if !current_klass.const_defined?(part, search_inheritance_chain)
+        return false
+      end
+
+      current_klass = current_klass.const_get(part)
+      current_prefix = "#{current_prefix}::#{part}"
+
+      if !Module.===(current_klass)
+        raise ArgumentError.new("#{current_prefix} is not a class or module")
       end
     end
 
-    return current_klass.===(val)
+    current_klass.===(val)
   end
 end

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

@@ -12,11 +12,11 @@
 # modules that override the `hash` method with something completely broken.
 module T::Private::Abstract::Data
   def self.get(mod, key)
-    mod.instance_variable_get("@opus_abstract__#{key}") # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    mod.instance_variable_get("@opus_abstract__#{key}")
   end
 
   def self.set(mod, key, value)
-    mod.instance_variable_set("@opus_abstract__#{key}", value) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    mod.instance_variable_set("@opus_abstract__#{key}", value)
   end
 
   def self.key?(mod, key)

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

@@ -111,16 +111,16 @@ module T::Private::Abstract::Validate
   end
 
   private_class_method def self.describe_method(method, show_owner: true)
-    if method.source_location
-      loc = method.source_location.join(':')
+    loc = if method.source_location
+      method.source_location.join(':')
     else
-      loc = "<unknown location>"
+      "<unknown location>"
     end
 
-    if show_owner
-      owner = " declared in #{method.owner}"
+    owner = if show_owner
+      " declared in #{method.owner}"
     else
-      owner = ""
+      ""
     end
 
     "    * `#{method.name}`#{owner} at #{loc}"

data/lib/types/private/casts.rb

@@ -2,6 +2,14 @@
 # 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
@@ -18,5 +26,24 @@ module T::Private
         value
       end
     end
+
+    # 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:)
+      begin
+        error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
+        return value unless error
+
+        caller_loc = T.must(caller_locations(2..2)).first
+
+        suffix = "Caller: #{T.must(caller_loc).path}:#{T.must(caller_loc).lineno}"
+
+        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)
+        value
+      end
+    end
   end
 end

data/lib/types/private/class_utils.rb

@@ -33,16 +33,16 @@ module T::Private::ClassUtils
       if @overwritten
         # The original method was overwritten. Overwrite again to restore it.
         T::Configuration.without_ruby_warnings do
-          @mod.send(:define_method, @old_method.name, @old_method) # rubocop:disable PrisonGuard/UsePublicSend
+          @mod.send(:define_method, @old_method.name, @old_method)
         end
       else
         # The original method was in an ancestor. Restore it by removing the overriding method.
-        @mod.send(:remove_method, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+        @mod.send(:remove_method, @old_method.name)
       end
 
       # Restore the visibility. Note that we need to do this even when we call remove_method
       # above, because the module may have set custom visibility for a method it inherited.
-      @mod.send(@visibility, @old_method.name) # rubocop:disable PrisonGuard/UsePublicSend
+      @mod.send(@visibility, @old_method.name)
 
       nil
     end
@@ -97,13 +97,13 @@ module T::Private::ClassUtils
     overwritten = original_owner == mod
     T::Configuration.without_ruby_warnings do
       T::Private::DeclState.current.without_on_method_added do
-        mod.send(:define_method, name, &blk) # rubocop:disable PrisonGuard/UsePublicSend
+        mod.send(:define_method, name, &blk)
         if blk.arity < 0 && mod.respond_to?(:ruby2_keywords, true)
           mod.send(:ruby2_keywords, name)
         end
       end
     end
-    mod.send(original_visibility, name) # rubocop:disable PrisonGuard/UsePublicSend
+    mod.send(original_visibility, name)
     new_method = mod.instance_method(name)
 
     ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)

data/lib/types/private/final.rb

@@ -37,7 +37,6 @@ module T::Private::Final
     mod.extend(mod.is_a?(Class) ? NoInherit : NoIncludeExtend)
     mark_as_final_module(mod)
     mark_as_final_module(mod.singleton_class)
-    T::Private::Methods.add_module_with_final(mod)
     T::Private::Methods.install_hooks(mod)
   end