sorbet-runtime 0.5.12164 → 0.5.12167

data/lib/types/props/decorator.rb

@@ -10,17 +10,17 @@
 class T::Props::Decorator
   extend T::Sig
 
-  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)}
+  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) }
 
   class NoRulesError < StandardError; end
 
   EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules], checked: false)
   private_constant :EMPTY_PROPS
 
-  sig {params(klass: T.untyped).void.checked(:never)}
+  sig { params(klass: T.untyped).void.checked(:never) }
   def initialize(klass)
     @class = T.let(klass, T.all(Module, T::Props::ClassMethods))
     @class.plugins.each do |mod|
@@ -30,22 +30,22 @@ class T::Props::Decorator
   end
 
   # checked(:never) - O(prop accesses)
-  sig {returns(T::Hash[Symbol, Rules]).checked(:never)}
+  sig { returns(T::Hash[Symbol, Rules]).checked(:never) }
   attr_reader :props
 
-  sig {returns(T::Array[Symbol])}
+  sig { returns(T::Array[Symbol]) }
   def all_props
     props.keys
   end
 
   # checked(:never) - O(prop accesses)
-  sig {params(prop: T.any(Symbol, String)).returns(Rules).checked(:never)}
+  sig { params(prop: T.any(Symbol, String)).returns(Rules).checked(:never) }
   def prop_rules(prop)
     props[prop.to_sym] || raise("No such prop: #{prop.inspect}")
   end
 
   # checked(:never) - Rules hash is expensive to check
-  sig {params(prop: Symbol, rules: Rules).void.checked(:never)}
+  sig { params(prop: Symbol, rules: Rules).void.checked(:never) }
   def add_prop_definition(prop, rules)
     override = rules.delete(:override)
 
@@ -79,16 +79,16 @@ class T::Props::Decorator
     extra
     setter_validate
     _tnilable
-  ].to_h {|k| [k, true]}.freeze, T::Hash[Symbol, T::Boolean], checked: false)
+  ].to_h { |k| [k, true] }.freeze, T::Hash[Symbol, T::Boolean], checked: false)
   private_constant :VALID_RULE_KEYS
 
-  sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+  sig { params(key: Symbol).returns(T::Boolean).checked(:never) }
   def valid_rule_key?(key)
     !!VALID_RULE_KEYS[key]
   end
 
   # checked(:never) - O(prop accesses)
-  sig {returns(T.all(Module, T::Props::ClassMethods)).checked(:never)}
+  sig { returns(T.all(Module, T::Props::ClassMethods)).checked(:never) }
   def decorated_class
     @class
   end
@@ -98,7 +98,7 @@ class T::Props::Decorator
   # Use this to validate that a value will validate for a given prop. Useful for knowing whether a value can be set on a model without setting it.
   #
   # checked(:never) - potentially O(prop accesses) depending on usage pattern
-  sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
+  sig { params(prop: Symbol, val: T.untyped).void.checked(:never) }
   def validate_prop_value(prop, val)
     prop_rules(prop).fetch(:value_validate_proc).call(val)
   end
@@ -202,7 +202,7 @@ class T::Props::Decorator
   end
 
   # TODO: we should really be checking all the methods on `cls`, not just Object
-  BANNED_METHOD_NAMES = T.let(Object.instance_methods.each_with_object({}) {|x, acc| acc[x] = true}.freeze, T::Hash[Symbol, TrueClass], checked: false)
+  BANNED_METHOD_NAMES = T.let(Object.instance_methods.each_with_object({}) { |x, acc| acc[x] = true }.freeze, T::Hash[Symbol, TrueClass], checked: false)
 
   # checked(:never) - Rules hash is expensive to check
   sig do
@@ -223,7 +223,7 @@ class T::Props::Decorator
         "to 'sensitivity:' (in prop #{@class.name}.#{name})")
     end
 
-    if rules.keys.any? {|k| !valid_rule_key?(k)}
+    if rules.keys.any? { |k| !valid_rule_key?(k) }
       raise ArgumentError.new("At least one invalid prop arg supplied in #{self}: #{rules.keys.inspect}")
     end
 
@@ -247,7 +247,7 @@ class T::Props::Decorator
   SAFE_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)}
+  sig { params(name: T.any(Symbol, String)).void.checked(:never) }
   private def validate_prop_name(name)
     if !name.match?(SAFE_NAME)
       raise ArgumentError.new("Invalid prop name in #{@class.name}: #{name}")
@@ -255,7 +255,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(Module).checked(:never) }
   private def convert_type_to_class(type)
     case type
     when T::Types::TypedArray, T::Types::FixedArray
@@ -392,7 +392,7 @@ class T::Props::Decorator
   end
 
   # checked(:never) - Rules hash is expensive to check
-  sig {params(name: Symbol, rules: Rules).void.checked(:never)}
+  sig { params(name: Symbol, rules: Rules).void.checked(:never) }
   private def define_getter_and_setter(name, rules)
     T::Configuration.without_ruby_warnings do
       if !rules[:immutable]
@@ -440,7 +440,7 @@ class T::Props::Decorator
   end
 
   # checked(:never) - Rules hash is expensive to check
-  sig {params(prop_name: Symbol, rules: Rules).void.checked(:never)}
+  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]
@@ -612,7 +612,7 @@ 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: Module).void.checked(:never) }
   def model_inherited(child)
     child.extend(T::Props::ClassMethods)
     child = T.cast(child, T.all(Module, T::Props::ClassMethods))
@@ -656,19 +656,19 @@ class T::Props::Decorator
     end
   end
 
-  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  sig { params(child: T.all(Module, T::Props::ClassMethods), 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: T.all(Module, T::Props::ClassMethods), 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: Module).void.checked(:never) }
   def plugin(mod)
     decorated_class.plugins << mod
     T::Props::Plugin::Private.apply_class_methods(mod, decorated_class)

data/lib/types/props/generated_code_validation.rb

@@ -159,7 +159,7 @@ module T::Props
         assert_equal(:resbody, rescue_body.type)
         exceptions, assignment, handler = rescue_body.children
         assert_equal(:array, exceptions.type)
-        exceptions.children.each {|c| assert_equal(:const, c.type)}
+        exceptions.children.each { |c| assert_equal(:const, c.type) }
         assert_equal(:lvasgn, assignment.type)
         assert_equal([:e], assignment.children)
 
@@ -169,7 +169,7 @@ module T::Props
         receiver, method, *args = deserialization_error.children
         assert_equal(nil, receiver)
         assert_equal(:raise_deserialization_error, method)
-        args.each {|a| validate_lack_of_side_effects(a, whitelisted_methods_for_deserialize)}
+        args.each { |a| validate_lack_of_side_effects(a, whitelisted_methods_for_deserialize) }
 
         validate_lack_of_side_effects(val_return, whitelisted_methods_for_deserialize)
       else
@@ -222,12 +222,12 @@ module T::Props
         # Primitives & self are ok
       when :lvar, :arg, :ivar
         # Reading local & instance variables & arguments is ok
-        unless node.children.all? {|c| c.is_a?(Symbol)}
+        unless node.children.all? { |c| c.is_a?(Symbol) }
           raise ValidationError.new("Unexpected child for #{node.type}: #{node.inspect}")
         end
       when :args, :mlhs, :block, :begin, :if
         # Blocks etc are read-only if their contents are read-only
-        node.children.each {|c| validate_lack_of_side_effects(c, whitelisted_methods_by_receiver_type) if c}
+        node.children.each { |c| validate_lack_of_side_effects(c, whitelisted_methods_by_receiver_type) if c }
       when :send
         # Sends are riskier so check a whitelist
         receiver, method, *args = node.children

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -30,12 +30,12 @@ module T::Props
     #
     # Note it does _not_ prevent explicit calls to `eagerly_define_lazy_methods!`
     # from working.
-    sig {void}
+    sig { void }
     def self.disable_lazy_evaluation!
       @lazy_evaluation_disabled ||= true
     end
 
-    sig {returns(T::Boolean)}
+    sig { returns(T::Boolean) }
     def self.lazy_evaluation_enabled?
       !defined?(@lazy_evaluation_disabled) || !@lazy_evaluation_disabled
     end
@@ -43,17 +43,17 @@ module T::Props
     module DecoratorMethods
       extend T::Sig
 
-      sig {returns(T::Hash[Symbol, T.proc.returns(String)]).checked(:never)}
+      sig { returns(T::Hash[Symbol, T.proc.returns(String)]).checked(:never) }
       private def lazily_defined_methods
         @lazily_defined_methods ||= {}
       end
 
-      sig {returns(T::Hash[Symbol, T.untyped]).checked(:never)}
+      sig { returns(T::Hash[Symbol, T.untyped]).checked(:never) }
       private def lazily_defined_vm_methods
         @lazily_defined_vm_methods ||= {}
       end
 
-      sig {params(name: Symbol).void}
+      sig { params(name: Symbol).void }
       private def eval_lazily_defined_method!(name)
         if !HasLazilySpecializedMethods.lazy_evaluation_enabled?
           raise SourceEvaluationDisabled.new
@@ -68,7 +68,7 @@ module T::Props
         cls.send(:private, name)
       end
 
-      sig {params(name: Symbol).void}
+      sig { params(name: Symbol).void }
       private def eval_lazily_defined_vm_method!(name)
         if !HasLazilySpecializedMethods.lazy_evaluation_enabled?
           raise SourceEvaluationDisabled.new
@@ -80,7 +80,7 @@ module T::Props
         cls.send(:private, name)
       end
 
-      sig {params(name: Symbol, blk: T.proc.returns(String)).void}
+      sig { params(name: Symbol, blk: T.proc.returns(String)).void }
       private def enqueue_lazy_method_definition!(name, &blk)
         lazily_defined_methods[name] = blk
 
@@ -100,7 +100,7 @@ module T::Props
         cls.send(:private, name)
       end
 
-      sig {params(name: Symbol, blk: T.untyped).void}
+      sig { params(name: Symbol, blk: T.untyped).void }
       private def enqueue_lazy_vm_method_definition!(name, &blk)
         lazily_defined_vm_methods[name] = blk
 
@@ -115,7 +115,7 @@ module T::Props
         cls.send(:private, name)
       end
 
-      sig {void}
+      sig { void }
       def eagerly_define_lazy_methods!
         return if lazily_defined_methods.empty?
 
@@ -125,18 +125,18 @@ module T::Props
 
         cls = decorated_class
         cls.class_eval(source)
-        lazily_defined_methods.each_key {|name| cls.send(:private, name)}
+        lazily_defined_methods.each_key { |name| cls.send(:private, name) }
         lazily_defined_methods.clear
       end
 
-      sig {void}
+      sig { void }
       def eagerly_define_lazy_vm_methods!
         return if lazily_defined_vm_methods.empty?
 
         lazily_defined_vm_methods.values.map(&:call)
 
         cls = decorated_class
-        lazily_defined_vm_methods.each_key {|name| cls.send(:private, name)}
+        lazily_defined_vm_methods.each_key { |name| cls.send(:private, name) }
         lazily_defined_vm_methods.clear
       end
     end

data/lib/types/props/optional.rb

@@ -43,11 +43,11 @@ module T::Props::Optional::DecoratorMethods
   end
 
   # checked(:never) - O(runtime object construction)
-  sig {returns(T::Hash[Symbol, T::Props::Private::ApplyDefault]).checked(:never)}
+  sig { returns(T::Hash[Symbol, T::Props::Private::ApplyDefault]).checked(:never) }
   attr_reader :props_with_defaults
 
   # checked(:never) - O(runtime object construction)
-  sig {returns(T::Hash[Symbol, T::Props::Private::SetterFactory::SetterProc]).checked(:never)}
+  sig { returns(T::Hash[Symbol, T::Props::Private::SetterFactory::SetterProc]).checked(:never) }
   attr_reader :props_without_defaults
 
   def add_prop_definition(prop, rules)

data/lib/types/props/pretty_printable.rb

@@ -49,21 +49,21 @@ module T::Props::PrettyPrintable
   module DecoratorMethods
     extend T::Sig
 
-    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    sig { params(key: Symbol).returns(T::Boolean).checked(:never) }
     def valid_rule_key?(key)
       super || key == :inspect
     end
 
     # 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) }
     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 }
     def pretty_print_extra(instance, pp); end
   end
 end

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

@@ -9,28 +9,28 @@ module T::Props
       abstract!
 
       # checked(:never) - O(object construction x prop count)
-      sig {returns(SetterFactory::SetterProc).checked(:never)}
+      sig { returns(SetterFactory::SetterProc).checked(:never) }
       attr_reader :setter_proc
 
       # checked(:never) - We do this with `T.let` instead
-      sig {params(accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      sig { params(accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never) }
       def initialize(accessor_key, setter_proc)
         @accessor_key = T.let(accessor_key, Symbol)
         @setter_proc = T.let(setter_proc, SetterFactory::SetterProc)
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {abstract.returns(T.untyped).checked(:never)}
+      sig { abstract.returns(T.untyped).checked(:never) }
       def default; end
 
       # checked(:never) - O(object construction x prop count)
-      sig {abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      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])
 
       # 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: Module, 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)
@@ -67,7 +67,7 @@ module T::Props
       abstract!
 
       # checked(:never) - We do this with `T.let` instead
-      sig {params(default: BasicObject, accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      sig { params(default: BasicObject, accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never) }
       def initialize(default, accessor_key, setter_proc)
         # FIXME: Ideally we'd check here that the default is actually a valid
         # value for this field, but existing code relies on the fact that we don't.
@@ -80,7 +80,7 @@ module T::Props
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      sig { override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance)
         instance.instance_variable_set(@accessor_key, default)
       end
@@ -88,13 +88,13 @@ module T::Props
 
     class ApplyPrimitiveDefault < ApplyFixedDefault
       # checked(:never) - O(object construction x prop count)
-      sig {override.returns(T.untyped).checked(:never)}
+      sig { override.returns(T.untyped).checked(:never) }
       attr_reader :default
     end
 
     class ApplyComplexDefault < ApplyFixedDefault
       # checked(:never) - O(object construction x prop count)
-      sig {override.returns(T.untyped).checked(:never)}
+      sig { override.returns(T.untyped).checked(:never) }
       def default
         T::Props::Utils.deep_clone_object(@default)
       end
@@ -105,13 +105,13 @@ module T::Props
     # `some_empty_array.dup`
     class ApplyEmptyArrayDefault < ApplyDefault
       # checked(:never) - O(object construction x prop count)
-      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      sig { override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance)
         instance.instance_variable_set(@accessor_key, [])
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {override.returns(T::Array[T.untyped]).checked(:never)}
+      sig { override.returns(T::Array[T.untyped]).checked(:never) }
       def default
         []
       end
@@ -122,13 +122,13 @@ module T::Props
     # `some_empty_hash.dup`
     class ApplyEmptyHashDefault < ApplyDefault
       # checked(:never) - O(object construction x prop count)
-      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      sig { override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance)
         instance.instance_variable_set(@accessor_key, {})
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {override.returns(T::Hash[T.untyped, T.untyped]).checked(:never)}
+      sig { override.returns(T::Hash[T.untyped, T.untyped]).checked(:never) }
       def default
         {}
       end
@@ -153,7 +153,7 @@ module T::Props
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      sig { override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never) }
       def set_default(instance)
         # Use the actual setter to validate the factory returns a legitimate
         # value every time
@@ -161,7 +161,7 @@ module T::Props
       end
 
       # checked(:never) - O(object construction x prop count)
-      sig {override.returns(T.untyped).checked(:never)}
+      sig { override.returns(T.untyped).checked(:never) }
       def default
         @class.class_exec(&@factory)
       end

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

@@ -29,7 +29,7 @@ module T::Props
         .checked(:never)
       end
       def self.generate(props, defaults)
-        stored_props = props.reject {|_, rules| rules[:dont_store]}
+        stored_props = props.reject { |_, rules| rules[:dont_store] }
         parts = stored_props.map do |prop, rules|
           # All of these strings should already be validated (directly or
           # indirectly) in `validate_prop_name`, so we don't bother with a nice

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

@@ -10,7 +10,7 @@ module T::Props
       private_constant :Serialize
       class Deserialize; end
       private_constant :Deserialize
-      ModeType = T.type_alias {T.any(Serialize, Deserialize)}
+      ModeType = T.type_alias { T.any(Serialize, Deserialize) }
       private_constant :ModeType
 
       module Mode
@@ -63,7 +63,7 @@ module T::Props
           end
         when T::Types::Simple
           raw = type.raw_type
-          if NO_TRANSFORM_TYPES.any? {|cls| raw <= cls}
+          if NO_TRANSFORM_TYPES.any? { |cls| raw <= cls }
             nil
           elsif raw <= Float
             case mode
@@ -99,7 +99,7 @@ module T::Props
             else
               "#{varname}.nil? ? nil : #{inner}"
             end
-          elsif type.types.all? {|t| generate(t, mode, varname).nil?}
+          elsif type.types.all? { |t| generate(t, mode, varname).nil? }
             # Handle, e.g., T::Boolean
             nil
           else
@@ -122,8 +122,8 @@ module T::Props
           # NB: This deliberately does include `nil`, which means we know we
           # don't need to do any transforming.
           inner_known = type.types
-            .map {|t| generate(t, mode, varname)}
-            .reject {|t| t == dynamic_fallback}
+            .map { |t| generate(t, mode, varname) }
+            .reject { |t| t == dynamic_fallback }
             .uniq
 
           if inner_known.size != 1
@@ -151,7 +151,7 @@ module T::Props
         end
       end
 
-      sig {params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never)}
+      sig { params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never) }
       private_class_method def self.handle_serializable_subtype(varname, type, mode)
         case mode
         when Serialize
@@ -164,7 +164,7 @@ module T::Props
         end
       end
 
-      sig {params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never)}
+      sig { params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never) }
       private_class_method def self.handle_custom_type(varname, type, mode)
         case mode
         when Serialize
@@ -177,7 +177,7 @@ module T::Props
         end
       end
 
-      sig {params(type: Module).returns(T.nilable(String)).checked(:never)}
+      sig { params(type: Module).returns(T.nilable(String)).checked(:never) }
       private_class_method def self.module_name(type)
         T::Configuration.module_name_mangler.call(type)
       end

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

@@ -24,7 +24,7 @@ module T::Props
         .checked(:never)
       end
       def self.generate(props)
-        stored_props = props.reject {|_, rules| rules[:dont_store]}
+        stored_props = props.reject { |_, rules| rules[:dont_store] }
         parts = stored_props.map do |prop, rules|
           # All of these strings should already be validated (directly or
           # indirectly) in `validate_prop_name`, so we don't bother with a nice

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

@@ -6,9 +6,9 @@ module T::Props
     module SetterFactory
       extend T::Sig
 
-      SetterProc = T.type_alias {T.proc.params(val: T.untyped).void}
-      ValueValidationProc = T.type_alias {T.proc.params(val: T.untyped).void}
-      ValidateProc = T.type_alias {T.proc.params(prop: Symbol, value: T.untyped).void}
+      SetterProc = T.type_alias { T.proc.params(val: T.untyped).void }
+      ValueValidationProc = T.type_alias { T.proc.params(val: T.untyped).void }
+      ValidateProc = T.type_alias { T.proc.params(prop: Symbol, value: T.untyped).void }
 
       sig do
         params(
@@ -236,7 +236,7 @@ module T::Props
         base_message = "Can't set #{klass.name}.#{prop} to #{val.inspect} (instance of #{val.class}) - need a #{type}"
 
         pretty_message = "Parameter '#{prop}': #{base_message}\n"
-        caller_loc = caller_locations.find {|l| !l.to_s.include?('sorbet-runtime/lib/types/props')}
+        caller_loc = caller_locations.find { |l| !l.to_s.include?('sorbet-runtime/lib/types/props') }
         if caller_loc
           pretty_message += "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
         end

data/lib/types/props/serializable.rb

@@ -78,7 +78,7 @@ module T::Props::Serializable
 
     if hash.size > hash_keys_matching_props
       serialized_forms = self.class.decorator.prop_by_serialized_forms
-      extra = hash.reject {|k, _| serialized_forms.key?(k)}
+      extra = hash.reject { |k, _| serialized_forms.key?(k) }
 
       # `extra` could still be empty here if the input matches a `dont_store` prop;
       # historically, we just ignore those
@@ -111,7 +111,7 @@ module T::Props::Serializable
         new_obj[k.to_s] = recursive_stringify_keys(v)
       end
     elsif obj.is_a?(Array)
-      new_obj = obj.map {|v| recursive_stringify_keys(v)}
+      new_obj = obj.map { |v| recursive_stringify_keys(v) }
     else
       new_obj = obj
     end
@@ -126,7 +126,7 @@ module T::Props::Serializable
     if old_extra != new_extra
       difference =
         if old_extra
-          new_extra.reject {|k, v| old_extra[k] == v}
+          new_extra.reject { |k, v| old_extra[k] == v }
         else
           new_extra
         end
@@ -195,7 +195,7 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def required_props
-    @class.props.select {|_, v| T::Props::Utils.required_prop?(v)}.keys
+    @class.props.select { |_, v| T::Props::Utils.required_prop?(v) }.keys
   end
 
   def prop_dont_store?(prop)
@@ -228,11 +228,11 @@ module T::Props::Serializable::DecoratorMethods
     res = super
     prop_by_serialized_forms[serialized_form] = prop
     if T::Configuration.use_vm_prop_serde?
-      enqueue_lazy_vm_method_definition!(:__t_props_generated_serialize) {generate_serialize2}
-      enqueue_lazy_vm_method_definition!(:__t_props_generated_deserialize) {generate_deserialize2}
+      enqueue_lazy_vm_method_definition!(:__t_props_generated_serialize) { generate_serialize2 }
+      enqueue_lazy_vm_method_definition!(:__t_props_generated_deserialize) { generate_deserialize2 }
     else
-      enqueue_lazy_method_definition!(:__t_props_generated_serialize) {generate_serialize_source}
-      enqueue_lazy_method_definition!(:__t_props_generated_deserialize) {generate_deserialize_source}
+      enqueue_lazy_method_definition!(:__t_props_generated_serialize) { generate_serialize_source }
+      enqueue_lazy_method_definition!(:__t_props_generated_deserialize) { generate_deserialize_source }
     end
     res
   end
@@ -263,7 +263,7 @@ module T::Props::Serializable::DecoratorMethods
   def message_with_generated_source_context(error, generated_method, generate_source_method)
     generated_method = generated_method.to_s
     if error.backtrace_locations
-      line_loc = error.backtrace_locations.find {|l| l.base_label == generated_method}
+      line_loc = error.backtrace_locations.find { |l| l.base_label == generated_method }
       return unless line_loc
 
       line_num = line_loc.lineno
@@ -275,7 +275,7 @@ module T::Props::Serializable::DecoratorMethods
         # in `__t_props_generated_serialize'"
         "in `#{generated_method}'"
       end
-      line_label = error.backtrace.find {|l| l.end_with?(label)}
+      line_label = error.backtrace.find { |l| l.end_with?(label) }
       return unless line_label
 
       line_num = if line_label.start_with?("(eval)")

data/lib/types/props/type_validation.rb

@@ -11,7 +11,7 @@ module T::Props::TypeValidation
   module DecoratorMethods
     extend T::Sig
 
-    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    sig { params(key: Symbol).returns(T::Boolean).checked(:never) }
     def valid_rule_key?(key)
       super || key == :DEPRECATED_underspecified_type
     end
@@ -58,19 +58,19 @@ module T::Props::TypeValidation
     # If the type is fully valid, returns nil.
     #
     # checked(:never) - called potentially many times recursively
-    sig {params(type: T::Types::Base).returns(T.nilable(T::Types::Base)).checked(:never)}
+    sig { params(type: T::Types::Base).returns(T.nilable(T::Types::Base)).checked(:never) }
     private def find_invalid_subtype(type)
       case type
       when T::Types::TypedEnumerable
         find_invalid_subtype(type.type)
       when T::Types::FixedHash
-        type.types.values.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+        type.types.values.map { |subtype| find_invalid_subtype(subtype) }.compact.first
       when T::Types::Union, T::Types::FixedArray
         # `T.any` is valid if all of the members are valid
-        type.types.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+        type.types.map { |subtype| find_invalid_subtype(subtype) }.compact.first
       when T::Types::Intersection
         # `T.all` is valid if at least one of the members is valid
-        invalid = type.types.map {|subtype| find_invalid_subtype(subtype)}.compact
+        invalid = type.types.map { |subtype| find_invalid_subtype(subtype) }.compact
         if invalid.length == type.types.length
           invalid.first
         else

data/lib/types/props/utils.rb

@@ -13,7 +13,7 @@ module T::Props::Utils
     when Symbol, NilClass, Numeric
       what
     when Array
-      what.map {|v| deep_clone_object(v, freeze: freeze)}
+      what.map { |v| deep_clone_object(v, freeze: freeze) }
     when Hash
       h = what.class.new
       what.each do |k, v|