sorbet-runtime 0.6.12473 → 0.6.12598

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f39c8316a030588d8034f9b5af629ad6b9f73b97fc8e743e6cc0dddb3a01d068
-  data.tar.gz: 98220709558a565d6765b0dd0e8123054c3fca2e1bc4364da0c443d3c76e6f97
+  metadata.gz: ebfe10c877dc0338945dbddb20e6f27e2e4570c951fe1a82f170c48e2d04a954
+  data.tar.gz: 5f73781d8a144940b29b411882aa9aa715b7e8096b649a7aeec5144d9d828199
 SHA512:
-  metadata.gz: 98a4f90009a82357da81795f493edb4784735d8375be770ebb4e55ecdb585ecc9de58fc26cbe56588e57ba3add4db9d3d6c0eaa7f9a4b005f07aab856419199f
-  data.tar.gz: c49f9d84a3c4fd906319ea0d704bb51799e3e22844c54f1b9c8f73870547fd5f1a815972683bdd2c2969f357ad145f6dec61728746365686ddc0179444104cf3
+  metadata.gz: 0cb2d697f780a36b05d24fecebbd931d03ba0947226f9df95e1ea083c69992fc52d1eb0688ad4ee14adadf370e97d3f334ba7c16a77a9aca310de7ff2e2f711a
+  data.tar.gz: 6876486f827f3e236a8bc7cf3cf323a1a09048ec9cb912d9b57cf30a0ee5b4d21e81915c4a935861fdd6b2982417e3aec23af602051f01181a481fd3ce1fc53b

data/lib/types/configuration.rb

@@ -546,16 +546,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/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/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/decorator.rb

@@ -174,7 +174,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 +196,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
 
@@ -238,7 +242,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)
@@ -259,6 +265,8 @@ class T::Props::Decorator
   end
 
   SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, 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/.freeze, Regexp, checked: false)
 
   # Used to validate both prop names and serialized forms
   sig { params(name: T.any(Symbol, String)).void.checked(:never) }
@@ -319,9 +327,9 @@ class T::Props::Decorator
   sig(:final) { params(name: Symbol).returns(T::Boolean).checked(:never) }
   private def method_defined_on_ancestor?(name)
     (@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))
+    # 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))
   end
 
   sig(:final) { params(name: Symbol, rules: Rules).void.checked(:never) }
@@ -402,8 +410,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 +485,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(

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/private/deserializer_generator.rb

@@ -16,6 +16,8 @@ module T::Props
     module DeserializerGenerator
       extend T::Sig
 
+      CAN_USE_SYMBOL_NAME = T.let(RUBY_VERSION >= "3.3.0", T::Boolean)
+
       # Generate a method that takes a T::Hash[String, T.untyped] representing
       # serialized props, sets instance variables for each prop found in the
       # input, and returns the count of we props set (which we can use to check
@@ -29,19 +31,21 @@ module T::Props
         .checked(:never)
       end
       def self.generate(props, defaults)
-        stored_props = props.reject { |_, rules| rules[:dont_store] }
-        parts = stored_props.map do |prop, rules|
+        parts = props.filter_map do |prop, rules|
+          next if rules[:dont_store]
+
           # All of these strings should already be validated (directly or
           # indirectly) in `validate_prop_name`, so we don't bother with a nice
           # error message, but we double check here to prevent a refactoring
           # from introducing a security vulnerability.
-          raise unless T::Props::Decorator::SAFE_NAME.match?(prop.to_s)
+          raise unless T::Props::Decorator::SAFE_NAME.match?(CAN_USE_SYMBOL_NAME ? prop.name : prop.to_s)
 
           hash_key = rules.fetch(:serialized_form)
           raise unless T::Props::Decorator::SAFE_NAME.match?(hash_key)
 
-          ivar_name = rules.fetch(:accessor_key).to_s
-          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_NAME.match?(ivar_name[1..-1])
+          key = rules.fetch(:accessor_key)
+          ivar_name = CAN_USE_SYMBOL_NAME ? key.name : key.to_s
+          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_ACCESSOR_KEY_NAME.match?(ivar_name)
 
           transformation = SerdeTransform.generate(
             T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),
@@ -90,7 +94,7 @@ module T::Props
 
         <<~RUBY
           def __t_props_generated_deserialize(hash)
-            found = #{stored_props.size}
+            found = #{parts.size}
             #{parts.join("\n\n")}
             found
           end

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

@@ -16,6 +16,8 @@ module T::Props
     module SerializerGenerator
       extend T::Sig
 
+      CAN_USE_SYMBOL_NAME = T.let(RUBY_VERSION >= "3.3.0", T::Boolean)
+
       sig do
         params(
           props: T::Hash[Symbol, T::Hash[Symbol, T.untyped]],
@@ -24,19 +26,21 @@ module T::Props
         .checked(:never)
       end
       def self.generate(props)
-        stored_props = props.reject { |_, rules| rules[:dont_store] }
-        parts = stored_props.map do |prop, rules|
+        parts = props.filter_map do |prop, rules|
+          next if rules[:dont_store]
+
           # All of these strings should already be validated (directly or
           # indirectly) in `validate_prop_name`, so we don't bother with a nice
           # error message, but we double check here to prevent a refactoring
           # from introducing a security vulnerability.
-          raise unless T::Props::Decorator::SAFE_NAME.match?(prop.to_s)
+          raise unless T::Props::Decorator::SAFE_NAME.match?(CAN_USE_SYMBOL_NAME ? prop.name : prop.to_s)
 
           hash_key = rules.fetch(:serialized_form)
           raise unless T::Props::Decorator::SAFE_NAME.match?(hash_key)
 
-          ivar_name = rules.fetch(:accessor_key).to_s
-          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_NAME.match?(ivar_name[1..-1])
+          key = rules.fetch(:accessor_key)
+          ivar_name = CAN_USE_SYMBOL_NAME ? key.name : key.to_s
+          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_ACCESSOR_KEY_NAME.match?(ivar_name)
 
           transformed_val = SerdeTransform.generate(
             T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),

data/lib/types/props/serializable.rb

@@ -121,8 +121,8 @@ module T::Props::Serializable
   private def with_existing_hash(changed_props, existing_hash:)
     serialized = existing_hash
     new_val = self.class.from_hash(serialized.merge(recursive_stringify_keys(changed_props)))
-    old_extra = self.instance_variable_get(:@_extra_props) if self.instance_variable_defined?(:@_extra_props)
-    new_extra = new_val.instance_variable_get(:@_extra_props) if new_val.instance_variable_defined?(:@_extra_props)
+    old_extra = self.instance_variable_get(:@_extra_props)
+    new_extra = new_val.instance_variable_get(:@_extra_props)
     if old_extra != new_extra
       difference =
         if old_extra
@@ -137,8 +137,7 @@ module T::Props::Serializable
 
   # Asserts if this property is missing during strict serialize
   private def required_prop_missing_from_serialize(prop)
-    if defined?(@_required_props_missing_from_deserialize) &&
-       @_required_props_missing_from_deserialize&.include?(prop)
+    if @_required_props_missing_from_deserialize&.include?(prop)
       # If the prop was already missing during deserialization, that means the application
       # code already had to deal with a nil value, which means we wouldn't be accomplishing
       # much by raising here (other than causing an unnecessary breakage).
@@ -353,11 +352,7 @@ module T::Props::Serializable::DecoratorMethods
   private_constant :EMPTY_EXTRA_PROPS
 
   def extra_props(instance)
-    if instance.instance_variable_defined?(:@_extra_props)
-      instance.instance_variable_get(:@_extra_props) || EMPTY_EXTRA_PROPS
-    else
-      EMPTY_EXTRA_PROPS
-    end
+    instance.instance_variable_get(:@_extra_props) || EMPTY_EXTRA_PROPS
   end
 
   # adds to the default result of T::Props::PrettyPrintable

data/lib/types/types/t_enum.rb

@@ -34,6 +34,8 @@ module T::Types
       case other
       when TEnum
         @val == other.val
+      when Simple
+        other.raw_type.===(@val)
       else
         false
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.12473
+  version: 0.6.12598
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-30 00:00:00.000000000 Z
+date: 2025-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest