sorbet-runtime 0.6.12449 → 0.6.12872

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ff0f5980373a88353853602b3a4189fa30606d521590a275a5e7a9c1975f0ad
-  data.tar.gz: a78f95a6c6d6e62cebb983a636b652a6d91a3914679305f32bd74b8866684759
+  metadata.gz: f1df82030d7eef7b4581bd982da33dafd6667515045b5e32e36d95d2cd96e876
+  data.tar.gz: c6b5c03495c971851b599f2465ce86a983a23b7455b9766755b77da9916b2d38
 SHA512:
-  metadata.gz: b426d793bdb378528590f2d3d68e4ca0458ae81d9c5ea126ea8a7c6b5a8e295b094f85f9c0151ff58cdc577d04fee8cc7880b45390071dda46d8492e07f0204b
-  data.tar.gz: e651470c0acf174f8789cce1bea7fe857326c751f1055ea97c6e952799d0355d7dc3a219fa2594327c58bf895ae291ae3b0f82167ef6d5c194395b986f9e4e3a
+  metadata.gz: 1491c37794b1e008c76728181aa3fdeb4fa7ac16c995d9c9d8477d7b5a6bd557c921781097d07f060b378de14648050cd773b35735ad46129fe074b888495fe4
+  data.tar.gz: 84d80bada939f468b9580708a11a63f3b08ab61c411b79d202afe294beab896f886213aa044d718170fcabced529be555ee08083be70b6f85f66ea61421ac6c2

data/lib/sorbet-runtime.rb

@@ -85,6 +85,7 @@ require_relative 'types/boolean'
 
 # Depends on types/utils
 require_relative 'types/types/typed_array'
+require_relative 'types/types/typed_module'
 require_relative 'types/types/typed_class'
 
 # Props dependencies
@@ -114,6 +115,5 @@ require_relative 'types/props/private/parser'
 require_relative 'types/props/generated_code_validation'
 
 require_relative 'types/struct'
-require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -367,4 +367,16 @@ module T
       end
     end
   end
+
+  module Module
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedModule::Untyped::Private::INSTANCE
+      elsif type.is_a?(T::Types::Anything)
+        T::Types::TypedModule::Anything::Private::INSTANCE
+      else
+        T::Types::TypedModule::Private::Pool.type_for_module(type)
+      end
+    end
+  end
 end

data/lib/types/configuration.rb

@@ -2,9 +2,6 @@
 # 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.
@@ -448,11 +445,7 @@ module T::Configuration
   MODULE_NAME = Module.instance_method(:name)
   private_constant :MODULE_NAME
 
-  @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 } # rubocop:disable Performance/BindCall
-  end
+  @default_module_name_mangler = ->(type) { MODULE_NAME.bind_call(type) }
 
   @module_name_mangler = nil
 
@@ -462,7 +455,7 @@ module T::Configuration
 
   # Set to override the default behavior for converting types
   #   to names in generated code. Used by the runtime implementation
-  #   associated with `--stripe-packages` mode.
+  #   associated with `--sorbet-packages` mode.
   #
   # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
   #   to a String (pass nil to reset to default behavior)
@@ -546,16 +539,6 @@ 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
-
   @sealed_violation_whitelist = nil
   # @param [Array] sealed_violation_whitelist An array of Regexp to validate
   #   whether inheriting /including a sealed module outside the defining module

data/lib/types/enum.rb

@@ -273,7 +273,7 @@ class T::Enum
 
   ### Private implementation ###
 
-  UNSET = T.let(Module.new.freeze, Module)
+  UNSET = T.let(Module.new.freeze, T::Module[T.anything])
   private_constant :UNSET
 
   sig { params(serialized_val: SerializedVal).void }

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

@@ -12,7 +12,7 @@
 # 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}") if key?(mod, key)
+    mod.instance_variable_get("@opus_abstract__#{key}")
   end
 
   def self.set(mod, key, value)

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

@@ -104,24 +104,6 @@ module T::Private::Methods
     T::Types::Proc.new(decl.params, decl.returns)
   end
 
-  # Returns the signature for a method whose definition was preceded by `sig`.
-  #
-  # @param method [UnboundMethod]
-  # @return [T::Private::Methods::Signature]
-  def self.signature_for_method(method)
-    signature_for_key(method_to_key(method))
-  end
-
-  private_class_method def self.signature_for_key(key)
-    maybe_run_sig_block_for_key(key)
-
-    # If a subclass Sub inherits a method `foo` from Base, then
-    # Sub.instance_method(:foo) != Base.instance_method(:foo) even though they resolve to the
-    # same method. Similarly, Foo.method(:bar) != Foo.singleton_class.instance_method(:bar).
-    # So, we always do the look up by the method on the owner (Base in this example).
-    @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
@@ -275,10 +257,8 @@ module T::Private::Methods
         # make sure to keep changes in sync.
         elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
           CallValidation.validate_call(self, original_method, method_sig, args, blk)
-        elsif T::Configuration::AT_LEAST_RUBY_2_7
-          original_method.bind_call(self, *args, &blk)
         else
-          original_method.bind(self).call(*args, &blk) # rubocop:disable Performance/BindCall
+          original_method.bind_call(self, *args, &blk)
         end
       end
     end
@@ -407,6 +387,19 @@ module T::Private::Methods
     end
   end
 
+  # Returns the signature for a method whose definition was preceded by `sig`.
+  #
+  # @param method [UnboundMethod]
+  # @return [T::Private::Methods::Signature]
+  def self.signature_for_method(method)
+    signature_for_key(method_to_key(method))
+  end
+
+  private_class_method def self.signature_for_key(key)
+    maybe_run_sig_block_for_key(key)
+    @signatures_by_method[key]
+  end
+
   def self.unwrap_method(mod, signature, original_method)
     maybe_wrapped_method = CallValidation.wrap_method_if_needed(mod, signature, original_method)
     @signatures_by_method[method_to_key(maybe_wrapped_method)] = signature
@@ -433,6 +426,25 @@ module T::Private::Methods
     run_sig_block_for_key(method_to_key(method))
   end
 
+  # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.
+  private_class_method def self.method_owner_and_name_to_key(owner, name)
+    "#{owner.object_id}##{name}"
+  end
+
+  private_class_method def self.method_to_key(method)
+    # If a subclass Sub inherits a method `foo` from Base, then
+    # Sub.instance_method(:foo) != Base.instance_method(:foo) even though they resolve to the
+    # same method. Similarly, Foo.method(:bar) != Foo.singleton_class.instance_method(:bar).
+    # So, we always do the look up by the method on the owner (Base in this example).
+    method_owner_and_name_to_key(method.owner, method.name)
+  end
+
+  private_class_method def self.key_to_method(key)
+    id, name = key.split("#")
+    obj = ObjectSpace._id2ref(id.to_i)
+    obj.instance_method(name)
+  end
+
   private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
@@ -516,27 +528,15 @@ module T::Private::Methods
       @old_hooks = nil
     else
       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
+        old_included.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       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
+        old_extended.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
       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
+        old_inherited.bind_call(self, arg)
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]
@@ -604,21 +604,6 @@ module T::Private::Methods
       mod.method(name)
     end
   end
-
-  # use this directly if you don't want/need to box up the method into an object to pass to method_to_key.
-  private_class_method def self.method_owner_and_name_to_key(owner, name)
-    "#{owner.object_id}##{name}"
-  end
-
-  private_class_method def self.method_to_key(method)
-    method_owner_and_name_to_key(method.owner, method.name)
-  end
-
-  private_class_method def self.key_to_method(key)
-    id, name = key.split("#")
-    obj = ObjectSpace._id2ref(id.to_i)
-    obj.instance_method(name)
-  end
 end
 
 # This has to be here, and can't be nested inside `T::Private::Methods`,

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

@@ -79,13 +79,13 @@ module T::Private::Methods::CallValidation
 
     # All the types for which valid? unconditionally returns `true`
     return_is_ignorable =
-      (method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
-       method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
-       method_sig.return_type.is_a?(T::Types::TypeParameter) ||
-       method_sig.return_type.is_a?(T::Types::TypeVariable) ||
-       (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject)))
+      method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+      method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+      method_sig.return_type.is_a?(T::Types::TypeParameter) ||
+      method_sig.return_type.is_a?(T::Types::TypeVariable) ||
+      (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject))
 
     returns_anything_method = all_args_are_simple && return_is_ignorable
 
@@ -176,7 +176,7 @@ module T::Private::Methods::CallValidation
     # this code is sig validation code.
     # Please issue `finish` to step out of it
 
-    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+    return_value = original_method.bind_call(instance, *args, &blk)
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -279,7 +279,7 @@ module T::Private::Methods::CallValidation
     # this code is sig validation code.
     # Please issue `finish` to step out of it
 
-    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+    return_value = original_method.bind_call(instance, *args, &blk)
 
     # The only type that is allowed to change the return value is `.void`.
     # It ignores what you returned and changes it to be a private singleton.
@@ -332,8 +332,4 @@ module T::Private::Methods::CallValidation
   end
 end
 
-if T::Configuration::AT_LEAST_RUBY_2_7
-  require_relative './call_validation_2_7'
-else
-  require_relative './call_validation_2_6'
-end
+require_relative './call_validation_2_7'

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

@@ -277,6 +277,9 @@ module T::Private::Methods::SignatureValidation
     end
   end
 
+  ALLOW_INCOMPATIBLE_VISIBILITY = [:visibility, true].freeze
+  private_constant :ALLOW_INCOMPATIBLE_VISIBILITY
+
   def self.validate_override_visibility(signature, super_signature)
     return if super_signature.mode == Modes.untyped
     # This departs from the behavior of other `validate_override_whatever` functions in that it
@@ -284,8 +287,8 @@ module T::Private::Methods::SignatureValidation
     # done because the primary method for silencing these errors (`allow_incompatible: :visibility`)
     # requires an `override` node to attach to. Once we have static override checking for implicitly
     # overridden methods, we can remove this.
-    return unless [Modes.override, Modes.overridable_override].include?(signature.mode)
-    return if [:visibility, true].include?(signature.override_allow_incompatible)
+    return unless Modes::OVERRIDE_MODES.include?(signature.mode)
+    return if ALLOW_INCOMPATIBLE_VISIBILITY.include?(signature.override_allow_incompatible)
     method = signature.method
     super_method = super_signature.method
     mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
@@ -305,8 +308,11 @@ module T::Private::Methods::SignatureValidation
   end
 
   # Higher = more restrictive.
+  METHOD_VISIBILITIES = %i[public protected private].freeze
+  private_constant :METHOD_VISIBILITIES
+
   private_class_method def self.visibility_strength(vis)
-    %i[public protected private].find_index(vis)
+    METHOD_VISIBILITIES.find_index(vis)
   end
 
   private_class_method def self.base_override_loc_str(signature, super_signature)

data/lib/types/private/sealed.rb

@@ -70,7 +70,7 @@ module T::Private::Sealed
 
   def self.validate_inheritance(caller_loc, parent, child, verb)
     this_file = caller_loc&.path
-    decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file) if sealed_module?(parent)
+    decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file)
 
     if !this_file
       raise "Could not use backtrace to determine file for #{verb} child #{child}"

data/lib/types/props/_props.rb

@@ -132,17 +132,14 @@ module T::Props
     end
 
     # Shorthand helper to define a `prop` with `immutable => true`
-    sig { params(name: Symbol, cls_or_args: T.untyped, args: T.untyped).void }
-    def const(name, cls_or_args, **args)
-      if (cls_or_args.is_a?(Hash) && cls_or_args.key?(:immutable)) || args.key?(:immutable)
+    sig { params(name: Symbol, cls: T.untyped, rules: T.untyped).void }
+    def const(name, cls, **rules)
+      if rules.key?(:immutable)
         Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")
       end
 
-      if cls_or_args.is_a?(Hash)
-        self.prop(name, **cls_or_args.merge(immutable: true))
-      else
-        self.prop(name, cls_or_args, **args.merge(immutable: true))
-      end
+      rules[:immutable] = true
+      self.prop(name, cls, **rules)
     end
 
     def included(child)

data/lib/types/props/custom_type.rb

@@ -50,7 +50,7 @@ module T::Props
     sig { abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never) }
     def deserialize(scalar); end
 
-    sig { override.params(_base: Module).void }
+    sig { override.params(_base: T::Module[T.anything]).void }
     def self.included(_base)
       super
 

data/lib/types/props/decorator.rb

@@ -13,8 +13,10 @@ class T::Props::Decorator
   Rules = T.type_alias { T::Hash[Symbol, T.untyped] }
   DecoratedInstance = T.type_alias { Object } # Would be T::Props, but that produces circular reference errors in some circumstances
   PropType = T.type_alias { T::Types::Base }
-  PropTypeOrClass = T.type_alias { T.any(PropType, Module) }
+  PropTypeOrClass = T.type_alias { T.any(PropType, T::Module[T.anything]) }
   OverrideRules = T.type_alias { T::Hash[Symbol, {allow_incompatible: T::Boolean}] }
+  DecoratedClassType = T.type_alias { T.all(T::Module[T.anything], T::Props::ClassMethods) }
+  private_constant :DecoratedClassType
 
   class NoRulesError < StandardError; end
 
@@ -38,7 +40,7 @@ class T::Props::Decorator
 
   sig { params(klass: T.untyped).void.checked(:never) }
   def initialize(klass)
-    @class = T.let(klass, T.all(Module, T::Props::ClassMethods))
+    @class = T.let(klass, DecoratedClassType)
     @class.plugins.each do |mod|
       T::Props::Plugin::Private.apply_decorator_methods(mod, self)
     end
@@ -102,7 +104,7 @@ class T::Props::Decorator
   end
 
   # checked(:never) - O(prop accesses)
-  sig { returns(T.all(Module, T::Props::ClassMethods)).checked(:never) }
+  sig { returns(DecoratedClassType).checked(:never) }
   def decorated_class
     @class
   end
@@ -174,7 +176,9 @@ class T::Props::Decorator
     .checked(:never)
   end
   def prop_get(instance, prop, rules=prop_rules(prop))
-    val = instance.instance_variable_get(rules[:accessor_key]) if instance.instance_variable_defined?(rules[:accessor_key])
+    # `instance_variable_get` will return nil if the variable doesn't exist
+    # which is what we want to have happen for the logic below.
+    val = instance.instance_variable_get(rules[:accessor_key])
     if !val.nil?
       val
     elsif (d = rules[:ifunset])
@@ -194,7 +198,9 @@ class T::Props::Decorator
     .checked(:never)
   end
   def prop_get_if_set(instance, prop, rules=prop_rules(prop))
-    instance.instance_variable_get(rules[:accessor_key]) if instance.instance_variable_defined?(rules[:accessor_key])
+    # `instance_variable_get` will return nil if the variable doesn't exist
+    # which is what we want to have happen for the return value here.
+    instance.instance_variable_get(rules[:accessor_key])
   end
   alias_method :get, :prop_get_if_set # Alias for backwards compatibility
 
@@ -203,7 +209,7 @@ class T::Props::Decorator
     params(
       instance: DecoratedInstance,
       prop: Symbol,
-      foreign_class: Module,
+      foreign_class: T::Module[T.anything],
       rules: Rules,
       opts: T::Hash[Symbol, T.untyped],
     )
@@ -222,7 +228,7 @@ class T::Props::Decorator
   sig do
     params(
       name: Symbol,
-      cls: Module,
+      cls: T::Module[T.anything],
       rules: Rules,
       type: PropTypeOrClass
     )
@@ -238,7 +244,9 @@ class T::Props::Decorator
     end
 
     if rules.keys.any? { |k| !valid_rule_key?(k) }
-      raise ArgumentError.new("At least one invalid prop arg supplied in #{self}: #{rules.keys.inspect}")
+      invalid_keys = rules.keys.reject { |k| valid_rule_key?(k) }
+      suffix = invalid_keys.size == 1 ? "" : "s"
+      raise ArgumentError.new("Invalid prop arg#{suffix} supplied in #{self}: #{invalid_keys.inspect}")
     end
 
     if !rules[:clobber_existing_method!] && !rules[:without_accessors] && BANNED_METHOD_NAMES.include?(name.to_sym)
@@ -258,7 +266,9 @@ class T::Props::Decorator
     nil
   end
 
-  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp, checked: false)
+  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/, Regexp, checked: false)
+  # Should be exactly the same as `SAFE_NAME`, but with a leading `@`.
+  SAFE_ACCESSOR_KEY_NAME = T.let(/\A@[A-Za-z_][A-Za-z0-9_-]*\z/, Regexp, checked: false)
 
   # Used to validate both prop names and serialized forms
   sig { params(name: T.any(Symbol, String)).void.checked(:never) }
@@ -269,7 +279,7 @@ class T::Props::Decorator
   end
 
   # This converts the type from a T::Type to a regular old ruby class.
-  sig { params(type: T::Types::Base).returns(Module).checked(:never) }
+  sig { params(type: T::Types::Base).returns(T::Module[T.anything]).checked(:never) }
   private def convert_type_to_class(type)
     case type
     when T::Types::TypedArray, T::Types::FixedArray
@@ -321,7 +331,7 @@ class T::Props::Decorator
     (@class.method_defined?(name) || @class.private_method_defined?(name)) &&
       # Unfortunately, older versions of ruby don't allow the second parameter on
       # `private_method_defined?`.
-      (!@class.method_defined?(name, false) && !@class.private_method_defined?(name, false))
+      !@class.method_defined?(name, false) && !@class.private_method_defined?(name, false)
   end
 
   sig(:final) { params(name: Symbol, rules: Rules).void.checked(:never) }
@@ -402,8 +412,6 @@ class T::Props::Decorator
 
     # extra arbitrary metadata attached by the code defining this property
 
-    validate_not_missing_sensitivity(name, rules)
-
     # for backcompat (the `:array` key is deprecated but because the name is
     # so generic it's really hard to be sure it's not being relied on anymore)
     if type.is_a?(T::Types::TypedArray)
@@ -479,35 +487,6 @@ class T::Props::Decorator
     end
   end
 
-  # checked(:never) - Rules hash is expensive to check
-  sig { params(prop_name: Symbol, rules: Rules).void.checked(:never) }
-  private def validate_not_missing_sensitivity(prop_name, rules)
-    if rules[:sensitivity].nil?
-      if rules[:redaction]
-        T::Configuration.hard_assert_handler(
-          "#{@class}##{prop_name} has a 'redaction:' annotation but no " \
-          "'sensitivity:' annotation. This is probably wrong, because if a " \
-          "prop needs redaction then it is probably sensitive. Add a " \
-          "sensitivity annotation like 'sensitivity: Opus::Sensitivity::PII." \
-          "whatever', or explicitly override this check with 'sensitivity: []'."
-        )
-      end
-      # TODO(PRIVACYENG-982) Ideally we'd also check for 'password' and possibly
-      # other terms, but this interacts badly with ProtoDefinedDocument because
-      # the proto syntax currently can't declare "sensitivity: []"
-      if /\bsecret\b/.match?(prop_name)
-        T::Configuration.hard_assert_handler(
-          "#{@class}##{prop_name} has the word 'secret' in its name, but no " \
-          "'sensitivity:' annotation. This is probably wrong, because if a " \
-          "prop is named 'secret' then it is probably sensitive. Add a " \
-          "sensitivity annotation like 'sensitivity: Opus::Sensitivity::NonPII." \
-          "security_token', or explicitly override this check with " \
-          "'sensitivity: []'."
-        )
-      end
-    end
-  end
-
   # Create `#{prop_name}_redacted` method
   sig do
     params(
@@ -609,7 +588,7 @@ class T::Props::Decorator
   sig do
     params(
       prop_name: Symbol,
-      prop_cls: Module,
+      prop_cls: T::Module[T.anything],
       rules: Rules,
       foreign: T.untyped,
     )
@@ -652,10 +631,10 @@ class T::Props::Decorator
   #
   # This gets called when a module or class that extends T::Props gets included, extended,
   # prepended, or inherited.
-  sig { params(child: Module).void.checked(:never) }
+  sig { params(child: T::Module[T.anything]).void.checked(:never) }
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
-    child = T.cast(child, T.all(Module, T::Props::ClassMethods))
+    child = T.cast(child, DecoratedClassType)
 
     child.plugins.concat(decorated_class.plugins)
     decorated_class.plugins.each do |mod|
@@ -742,19 +721,19 @@ class T::Props::Decorator
     result
   end
 
-  sig { params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never) }
+  sig { params(child: DecoratedClassType, prop: Symbol).returns(T::Boolean).checked(:never) }
   private def clobber_getter?(child, prop)
     !!(child.decorator.method(:prop_get).owner != method(:prop_get).owner &&
        child.instance_method(prop).source_location&.first == __FILE__)
   end
 
-  sig { params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never) }
+  sig { params(child: DecoratedClassType, prop: Symbol).returns(T::Boolean).checked(:never) }
   private def clobber_setter?(child, prop)
     !!(child.decorator.method(:prop_set).owner != method(:prop_set).owner &&
        child.instance_method("#{prop}=").source_location&.first == __FILE__)
   end
 
-  sig { params(mod: Module).void.checked(:never) }
+  sig { params(mod: T::Module[T.anything]).void.checked(:never) }
   def plugin(mod)
     decorated_class.plugins << mod
     T::Props::Plugin::Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -37,7 +37,7 @@ module T::Props
 
     sig { returns(T::Boolean) }
     def self.lazy_evaluation_enabled?
-      !defined?(@lazy_evaluation_disabled) || !@lazy_evaluation_disabled
+      !@lazy_evaluation_disabled
     end
 
     module DecoratorMethods

data/lib/types/props/pretty_printable.rb

@@ -12,8 +12,8 @@ module T::Props::PrettyPrintable
     pp.group(1, "<#{klass.inspect_class_with_decoration(self)}", ">") do
       klass.all_props.sort.each do |prop|
         pp.breakable
-        val = klass.get(self, prop)
         rules = klass.prop_rules(prop)
+        val = klass.get(self, prop, rules)
         pp.text("#{prop}=")
         if (custom_inspect = rules[:inspect])
           inspected = if T::Utils.arity(custom_inspect) == 1
@@ -22,8 +22,8 @@ module T::Props::PrettyPrintable
             custom_inspect.call(val, {multiline: multiline})
           end
           pp.text(inspected.nil? ? "nil" : inspected)
-        elsif rules[:sensitivity] && !rules[:sensitivity].empty? && !val.nil?
-          pp.text("<REDACTED #{rules[:sensitivity].join(', ')}>")
+        elsif (sensitivity = rules[:sensitivity]) && !sensitivity.empty? && !val.nil?
+          pp.text("<REDACTED #{sensitivity.join(', ')}>")
         else
           val.pretty_print(pp)
         end
@@ -56,14 +56,14 @@ module T::Props::PrettyPrintable
 
     # Overridable method to specify how the first part of a `pretty_print`d object's class should look like
     # NOTE: This is just to support Stripe's `PrettyPrintableModel` case, and not recommended to be overridden
-    sig { params(instance: T::Props::PrettyPrintable).returns(String) }
+    sig { params(instance: T::Props::PrettyPrintable).returns(String).checked(:never) }
     def inspect_class_with_decoration(instance)
       T.unsafe(instance).class.to_s
     end
 
     # Overridable method to add anything that is not a prop
     # NOTE: This is to support cases like Serializable's `@_extra_props`, and Stripe's `PrettyPrintableModel#@_deleted`
-    sig { params(instance: T::Props::PrettyPrintable, pp: T.any(PrettyPrint, PP::SingleLine)).void }
+    sig { params(instance: T::Props::PrettyPrintable, pp: T.any(PrettyPrint, PP::SingleLine)).void.checked(:never) }
     def pretty_print_extra(instance, pp); end
   end
 end

data/lib/types/props/private/apply_default.rb

@@ -27,10 +27,10 @@ module T::Props
       sig { abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance); end
 
-      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[Module])
+      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[T::Module[T.anything]])
 
       # checked(:never) - Rules hash is expensive to check
-      sig { params(cls: Module, rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never) }
+      sig { params(cls: T::Module[T.anything], rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never) }
       def self.for(cls, rules)
         accessor_key = rules.fetch(:accessor_key)
         setter = rules.fetch(:setter_proc)
@@ -138,7 +138,7 @@ module T::Props
       # checked(:never) - We do this with `T.let` instead
       sig do
         params(
-          cls: Module,
+          cls: T::Module[T.anything],
           factory: T.any(Proc, Method),
           accessor_key: Symbol,
           setter_proc: SetterFactory::SetterProc,
@@ -147,7 +147,7 @@ module T::Props
         .checked(:never)
       end
       def initialize(cls, factory, accessor_key, setter_proc)
-        @class = T.let(cls, Module)
+        @class = T.let(cls, T::Module[T.anything])
         @factory = T.let(factory, T.any(Proc, Method))
         super(accessor_key, setter_proc)
       end