sorbet-runtime 0.5.12152 → 0.5.12167

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79909fc042d94e9a6bca80891660324c8e341b37de6d00629990a27d459ff6f5
-  data.tar.gz: c697040eca408c72ea8a19eda671ee5f2dff5a90bad99ee9d50af6b2cc1a60b8
+  metadata.gz: 1d7a3351fc826cf6b033f19325787452f8c5c06523e4fbba59ef35e3e02d9fd5
+  data.tar.gz: e910cc9373e4fd3b9f2f23fe8c66d8e55dac434f4b390bfab87e5821d30fd774
 SHA512:
-  metadata.gz: 85f47a6b6b394c8b04d83355e89d056e7f2bf5c30d499a417e27f06fbf1d2a88e9f898d0764525a419d1b8de12de7b4cd92df2ac9ef1fe785899ae375fff04b3
-  data.tar.gz: a171538aecf649aa9bfc097eddee20c03bf5653ae24512233469b0a0479c35a80db4422901ab7a1092d7fab31c6df97930758b618e068b4598c36190b94ea31d
+  metadata.gz: d5a8b68195c978918b9bbdddeed99956147d737b3852d740130baeee06a587b00ddda47ca2440ffa7b6e343bb6d83b004c1a62526fa1fc9fb012ce31a453176b
+  data.tar.gz: 845b6a5df2b3094c155a462cfadd2e8b1d8345626f482e26bb0207a2d9eb549b25d1f355d7c9749240a1c13b0bc934c14b982dfe09738aedf1dd014e8e652e42

data/lib/types/_types.rb

@@ -27,7 +27,7 @@ module T
   def self.any(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?
+    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
 

data/lib/types/boolean.rb

@@ -4,5 +4,5 @@
 module T
   # T::Boolean is a type alias helper for the common `T.any(TrueClass, FalseClass)`.
   # Defined separately from _types.rb because it has a dependency on T::Types::Union.
-  Boolean = T.type_alias {T.any(TrueClass, FalseClass)}
+  Boolean = T.type_alias { T.any(TrueClass, FalseClass) }
 end

data/lib/types/configuration.rb

@@ -419,12 +419,12 @@ module T::Configuration
     if values.nil?
       @scalar_types = values
     else
-      bad_values = values.reject {|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
 
-      @scalar_types = values.each_with_object({}) {|x, acc| acc[x] = true}.freeze
+      @scalar_types = values.each_with_object({}) { |x, acc| acc[x] = true }.freeze
     end
   end
 
@@ -449,9 +449,9 @@ module T::Configuration
   private_constant :MODULE_NAME
 
   @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
-    ->(type) {MODULE_NAME.bind_call(type)}
+    ->(type) { MODULE_NAME.bind_call(type) }
   else
-    ->(type) {MODULE_NAME.bind(type).call} # rubocop:disable Performance/BindCall
+    ->(type) { MODULE_NAME.bind(type).call } # rubocop:disable Performance/BindCall
   end
 
   @module_name_mangler = nil

data/lib/types/enum.rb

@@ -44,11 +44,11 @@ class T::Enum
   extend T::Props::CustomType
 
   # TODO(jez) Might want to restrict this, or make subclasses provide this type
-  SerializedVal = T.type_alias {T.untyped}
+  SerializedVal = T.type_alias { T.untyped }
   private_constant :SerializedVal
 
   ### Enum class methods ###
-  sig {returns(T::Array[T.attached_class])}
+  sig { returns(T::Array[T.attached_class]) }
   def self.values
     if @values.nil?
       raise "Attempting to access values of #{self.class} before it has been initialized." \
@@ -59,7 +59,7 @@ class T::Enum
 
   # 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]))}
+  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)
@@ -72,7 +72,7 @@ class T::Enum
   #
   # Note: It would have been nice to make this method final before people started overriding it.
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never)}
+  sig { params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never) }
   def self.try_deserialize(serialized_val)
     if @mapping.nil?
       raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
@@ -88,7 +88,7 @@ class T::Enum
   #
   # @return [self]
   # @raise [KeyError] if serialized value does not match any instance.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never)}
+  sig { overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never) }
   def self.from_serialized(serialized_val)
     res = try_deserialize(serialized_val)
     if res.nil?
@@ -99,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).checked(:never)}
+  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." \
@@ -109,7 +109,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  sig { override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never) }
   def self.serialize(instance)
     # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
     # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
@@ -126,7 +126,7 @@ class T::Enum
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  sig { override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never) }
   def self.deserialize(mongo_value)
     if self == T::Enum
       raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
@@ -136,46 +136,46 @@ class T::Enum
 
   ### Enum instance methods ###
 
-  sig {returns(T.self_type)}
+  sig { returns(T.self_type) }
   def dup
     self
   end
 
-  sig {returns(T.self_type).checked(:tests)}
+  sig { returns(T.self_type).checked(:tests) }
   def clone
     self
   end
 
   # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {returns(SerializedVal).checked(:never)}
+  sig { returns(SerializedVal).checked(:never) }
   def serialize
     assert_bound!
     @serialized_val
   end
 
-  sig {params(args: T.untyped).returns(T.untyped)}
+  sig { params(args: T.untyped).returns(T.untyped) }
   def to_json(*args)
     serialize.to_json(*args)
   end
 
-  sig {params(args: T.untyped).returns(T.untyped)}
+  sig { params(args: T.untyped).returns(T.untyped) }
   def as_json(*args)
     serialized_val = serialize
     return serialized_val unless serialized_val.respond_to?(:as_json)
     serialized_val.as_json(*args)
   end
 
-  sig {returns(String)}
+  sig { returns(String) }
   def to_s
     inspect
   end
 
-  sig {returns(String)}
+  sig { returns(String) }
   def inspect
     "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
   end
 
-  sig {params(other: BasicObject).returns(T.nilable(Integer))}
+  sig { params(other: BasicObject).returns(T.nilable(Integer)) }
   def <=>(other)
     case other
     when self.class
@@ -192,7 +192,7 @@ class T::Enum
   # responds to the `to_str` method. It does not actually call `to_str` however.
   #
   # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
-  T::Sig::WithoutRuntime.sig {returns(String)}
+  T::Sig::WithoutRuntime.sig { returns(String) }
   def to_str
     msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
     if T::Configuration.legacy_t_enum_migration_mode?
@@ -200,7 +200,7 @@ class T::Enum
         msg,
         storytime: {
           class: self.class.name,
-          caller_location: Kernel.caller_locations(1..1)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+          caller_location: Kernel.caller_locations(1..1)&.[](0)&.then { "#{_1.path}:#{_1.lineno}" },
         },
       )
       serialize.to_s
@@ -217,12 +217,12 @@ class T::Enum
     if T.unsafe(false)
       # Declare to the type system that the `serialize` method for sure exists
       # on whatever we mix this into.
-      T::Sig::WithoutRuntime.sig {abstract.returns(T.untyped)}
+      T::Sig::WithoutRuntime.sig { abstract.returns(T.untyped) }
       def serialize; end
     end
 
     # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
-    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    T::Sig::WithoutRuntime.sig { params(other: BasicObject).returns(T::Boolean) }
     def ==(other)
       case other
       when String
@@ -238,7 +238,7 @@ class T::Enum
     end
 
     # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
-    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    T::Sig::WithoutRuntime.sig { params(other: BasicObject).returns(T::Boolean) }
     def ===(other)
       case other
       when String
@@ -255,7 +255,7 @@ class T::Enum
 
     # WithoutRuntime so that caller_locations can assume a constant stack depth
     # (Otherwise, the first call would be the method with the wrapping, which would have a different stack depth.)
-    T::Sig::WithoutRuntime.sig {params(method: Symbol, other: T.untyped).void}
+    T::Sig::WithoutRuntime.sig { params(method: Symbol, other: T.untyped).void }
     private def comparison_assertion_failed(method, other)
       T::Configuration.soft_assert_handler(
         'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
@@ -265,7 +265,7 @@ class T::Enum
           other: other,
           other_class: other.class.name,
           method: method,
-          caller_location: Kernel.caller_locations(2..2)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+          caller_location: Kernel.caller_locations(2..2)&.[](0)&.then { "#{_1.path}:#{_1.lineno}" },
         }
       )
     end
@@ -276,7 +276,7 @@ class T::Enum
   UNSET = T.let(Module.new.freeze, Module)
   private_constant :UNSET
 
-  sig {params(serialized_val: SerializedVal).void}
+  sig { params(serialized_val: SerializedVal).void }
   def initialize(serialized_val=UNSET)
     raise 'T::Enum is abstract' if self.class == T::Enum
     if !self.class.started_initializing?
@@ -292,7 +292,7 @@ class T::Enum
     self.class._register_instance(self)
   end
 
-  sig {returns(NilClass).checked(:never)}
+  sig { returns(NilClass).checked(:never) }
   private def assert_bound!
     if @const_name.nil?
       raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
@@ -300,14 +300,14 @@ class T::Enum
     end
   end
 
-  sig {params(const_name: Symbol).void}
+  sig { params(const_name: Symbol).void }
   def _bind_name(const_name)
     @const_name = const_name
     @serialized_val = const_to_serialized_val(const_name) if @serialized_val.equal?(UNSET)
     freeze
   end
 
-  sig {params(const_name: Symbol).returns(String)}
+  sig { params(const_name: Symbol).returns(String) }
   private def const_to_serialized_val(const_name)
     # Historical note: We convert to lowercase names because the majority of existing calls to
     # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
@@ -315,7 +315,7 @@ class T::Enum
     -const_name.to_s.downcase.freeze
   end
 
-  sig {returns(T::Boolean)}
+  sig { returns(T::Boolean) }
   def self.started_initializing?
     unless defined?(@started_initializing)
       @started_initializing = T.let(false, T.nilable(T::Boolean))
@@ -323,7 +323,7 @@ class T::Enum
     T.must(@started_initializing)
   end
 
-  sig {returns(T::Boolean)}
+  sig { returns(T::Boolean) }
   def self.fully_initialized?
     unless defined?(@fully_initialized)
       @fully_initialized = T.let(false, T.nilable(T::Boolean))
@@ -332,7 +332,7 @@ class T::Enum
   end
 
   # Maintains the order in which values are defined
-  sig {params(instance: T.untyped).void}
+  sig { params(instance: T.untyped).void }
   def self._register_instance(instance)
     @values ||= []
     @values << T.cast(instance, T.attached_class)
@@ -340,7 +340,7 @@ class T::Enum
 
   # Entrypoint for allowing people to register new enum values.
   # All enum values must be defined within this block.
-  sig {params(blk: T.proc.void).void}
+  sig { params(blk: T.proc.void).void }
   def self.enums(&blk)
     raise "enums cannot be defined for T::Enum" if self == T::Enum
     raise "Enum #{self} was already initialized" if fully_initialized?
@@ -375,13 +375,13 @@ class T::Enum
 
     orphaned_instances = T.must(@values) - @mapping.values
     if !orphaned_instances.empty?
-      raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
+      raise "Enum values must be assigned to constants: #{orphaned_instances.map { |v| v.instance_variable_get('@serialized_val') }}"
     end
 
     @fully_initialized = true
   end
 
-  sig {params(child_class: T::Class[T.anything]).void}
+  sig { params(child_class: T::Class[T.anything]).void }
   def self.inherited(child_class)
     super
 
@@ -394,12 +394,12 @@ class T::Enum
   end
 
   # Marshal support
-  sig {params(_level: Integer).returns(String)}
+  sig { params(_level: Integer).returns(String) }
   def _dump(_level)
     Marshal.dump(serialize)
   end
 
-  sig {params(args: String).returns(T.attached_class)}
+  sig { params(args: String).returns(T.attached_class) }
   def self._load(args)
     deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
   end

data/lib/types/non_forcing_constants.rb

@@ -4,7 +4,7 @@
 module T::NonForcingConstants
   # 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)}
+  T::Sig::WithoutRuntime.sig { params(val: BasicObject, klass: String).returns(T::Boolean) }
   def self.non_forcing_is_a?(val, klass)
     method_name = "T::NonForcingConstants.non_forcing_is_a?"
     if klass.empty?

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

@@ -25,7 +25,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}.compare_by_identity
+  @modules_with_final = Hash.new { |hash, key| hash[key] = nil }.compare_by_identity
   # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
   # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
   # in installed_hooks.
@@ -168,7 +168,7 @@ module T::Private::Methods
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.path.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
+        caller_loc = T::Private::CallerUtils.find_caller { |loc| !loc.path.to_s.start_with?(SORBET_RUNTIME_LIB_PATH) }
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -471,7 +471,7 @@ module T::Private::Methods
   end
 
   def self.all_checked_tests_sigs
-    @signatures_by_method.values.select {|sig| sig.check_level == :tests}
+    @signatures_by_method.values.select { |sig| sig.check_level == :tests }
   end
 
   # the module target is adding the methods from the module source to itself. we need to check that for all instance

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

@@ -69,11 +69,11 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
     has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
-      original_method.parameters.all? {|(kind, _name)| kind == :req || kind == :block}
+      original_method.parameters.all? { |(kind, _name)| kind == :req || kind == :block }
     can_skip_block_type = method_sig.block_type.nil? || method_sig.block_type.valid?(nil)
     ok_for_fast_path = has_fixed_arity && can_skip_block_type && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
 
-    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
+    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? { |_name, type| type.is_a?(T::Types::Simple) }
     simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
     simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
 

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

@@ -68,14 +68,14 @@ class T::Private::Methods::Signature
     writer_method = !(raw_arg_types.size == 1 && raw_arg_types.key?(nil)) && parameters == UNNAMED_REQUIRED_PARAMETERS && method_name[-1] == "="
     # For writer methods, map the single parameter to the method name without the "=" at the end
     parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
-    is_name_missing = parameters.any? {|_, name| !raw_arg_types.key?(name)}
+    is_name_missing = parameters.any? { |_, name| !raw_arg_types.key?(name) }
     if is_name_missing
-      param_names = parameters.map {|_, name| name}
+      param_names = parameters.map { |_, name| name }
       missing_names = param_names - raw_arg_types.keys
       raise "The declaration for `#{method.name}` is missing parameter(s): #{missing_names.join(', ')}"
     elsif parameters.length != raw_arg_types.size
-      param_names = parameters.map {|_, name| name}
-      has_extra_names = parameters.count {|_, name| raw_arg_types.key?(name)} < raw_arg_types.size
+      param_names = parameters.map { |_, name| name }
+      has_extra_names = parameters.count { |_, name| raw_arg_types.key?(name) } < raw_arg_types.size
       if has_extra_names
         extra_names = raw_arg_types.keys - param_names
         raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
@@ -95,7 +95,7 @@ class T::Private::Methods::Signature
         # always precede optional keyword arguments. We can't tell
         # whether the culprit is the Ruby reordering or user error, so
         # we error but include a note
-        if param_kind == :keyreq && parameters.any? {|k, _| k == :key}
+        if param_kind == :keyreq && parameters.any? { |k, _| k == :key }
           hint = "\n\nNote: Any required keyword arguments must precede any optional keyword " \
                  "arguments. If your method declaration matches your `def`, try reordering any " \
                  "optional keyword parameters to the end of the method list."
@@ -103,7 +103,7 @@ class T::Private::Methods::Signature
 
         raise "Parameter `#{type_name}` is declared out of order (declared as arg number " \
               "#{i + 1}, defined in the method as arg number " \
-              "#{parameters.index {|_, name| name == type_name} + 1}).#{hint}\nMethod: #{method_desc}"
+              "#{parameters.index { |_, name| name == type_name } + 1}).#{hint}\nMethod: #{method_desc}"
       end
 
       type = T::Utils.coerce(raw_type)
@@ -245,8 +245,8 @@ class T::Private::Methods::Signature
   end
 
   def force_type_init
-    @arg_types.each {|_, type| type.build_type}
-    @kwarg_types.each {|_, type| type.build_type}
+    @arg_types.each { |_, type| type.build_type }
+    @kwarg_types.each { |_, type| type.build_type }
     @block_type&.build_type
     @rest_type&.build_type
     @keyrest_type&.build_type

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

@@ -72,7 +72,7 @@ module T::Private::Methods::SignatureValidation
 
       # If the super_method has any kwargs we can't build a
       # Signature for it, so we'll just skip validation in that case.
-      if !super_signature && !super_method.parameters.select {|kind, _| kind == :rest || kind == :kwrest}.empty?
+      if !super_signature && !super_method.parameters.select { |kind, _| kind == :rest || kind == :kwrest }.empty?
         nil
       else
         # super_signature can be nil when we're overriding a method (perhaps a builtin) that didn't use

data/lib/types/private/mixins/mixins.rb

@@ -5,7 +5,7 @@ module T::Private
   module MixesInClassMethods
     def included(other)
       mods = Abstract::Data.get(self, :class_methods_mixins)
-      mods.each {|mod| other.extend(mod)}
+      mods.each { |mod| other.extend(mod) }
       super
     end
   end

data/lib/types/private/runtime_levels.rb

@@ -32,7 +32,7 @@ module T::Private::RuntimeLevels
   def self.enable_checking_in_tests
     if !@check_tests && @wrapped_tests_with_validation
       all_checked_tests_sigs = T::Private::Methods.all_checked_tests_sigs
-      locations = all_checked_tests_sigs.map {|sig| sig.method.source_location.join(':')}.join("\n- ")
+      locations = all_checked_tests_sigs.map { |sig| sig.method.source_location.join(':') }.join("\n- ")
       raise "Toggle `:tests`-level runtime type checking earlier. " \
         "There are already some methods wrapped with `sig.checked(:tests)`:\n" \
         "- #{locations}"

data/lib/types/private/sealed.rb

@@ -5,7 +5,7 @@ module T::Private::Sealed
   module NoInherit
     def inherited(child)
       super
-      caller_loc = T::Private::CallerUtils.find_caller {|loc| loc.base_label != 'inherited'}
+      caller_loc = T::Private::CallerUtils.find_caller { |loc| loc.base_label != 'inherited' }
       T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'inherited')
       @sorbet_sealed_module_all_subclasses << child
     end
@@ -22,14 +22,14 @@ module T::Private::Sealed
   module NoIncludeExtend
     def included(child)
       super
-      caller_loc = T::Private::CallerUtils.find_caller {|loc| loc.base_label != 'included'}
+      caller_loc = T::Private::CallerUtils.find_caller { |loc| loc.base_label != 'included' }
       T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'included')
       @sorbet_sealed_module_all_subclasses << child
     end
 
     def extended(child)
       super
-      caller_loc = T::Private::CallerUtils.find_caller {|loc| loc.base_label != 'extended'}
+      caller_loc = T::Private::CallerUtils.find_caller { |loc| loc.base_label != 'extended' }
       T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'extended')
       @sorbet_sealed_module_all_subclasses << child
     end
@@ -81,7 +81,7 @@ module T::Private::Sealed
 
     if !this_file.start_with?(decl_file)
       whitelist = T::Configuration.sealed_violation_whitelist
-      if !whitelist.nil? && whitelist.any? {|pattern| this_file =~ pattern}
+      if !whitelist.nil? && whitelist.any? { |pattern| this_file =~ pattern }
         return
       end
 

data/lib/types/props/_props.rb

@@ -109,7 +109,7 @@ module T::Props
     #   form.
     #
     # @return [void]
-    sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
+    sig { params(name: Symbol, cls: T.untyped, rules: T.untyped).void }
     def prop(name, cls, **rules)
       cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
       decorator.prop_defined(name, cls, rules)
@@ -132,7 +132,7 @@ 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}
+    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)
         Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")

data/lib/types/props/constructor.rb

@@ -15,7 +15,7 @@ module T::Props::Constructor::DecoratorMethods
   # we'll use to check for any unrecognized input.)
   #
   # checked(:never) - O(runtime object construction)
-  sig {params(instance: T::Props::Constructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  sig { params(instance: T::Props::Constructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never) }
   def construct_props_without_defaults(instance, hash)
     # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
     # and therefore allocates for each entry.

data/lib/types/props/custom_type.rb

@@ -39,7 +39,7 @@ module T::Props
     #
     # @param [Object] instance
     # @return An instance of one of T::Configuration.scalar_types
-    sig {abstract.params(instance: T.untyped).returns(T.untyped).checked(:never)}
+    sig { abstract.params(instance: T.untyped).returns(T.untyped).checked(:never) }
     def serialize(instance); end
 
     # Given the serialized form of your type, this returns an instance
@@ -47,17 +47,17 @@ module T::Props
     #
     # @param scalar One of T::Configuration.scalar_types
     # @return Object
-    sig {abstract.params(scalar: T.untyped).returns(T.untyped).checked(:never)}
+    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: Module).void }
     def self.included(_base)
       super
 
       raise 'Please use "extend", not "include" to attach this module'
     end
 
-    sig(:final) {params(val: T.untyped).returns(T::Boolean).checked(:never)}
+    sig(:final) { params(val: T.untyped).returns(T::Boolean).checked(:never) }
     def self.scalar_type?(val)
       # We don't need to check for val's included modules in
       # T::Configuration.scalar_types, because T::Configuration.scalar_types
@@ -74,7 +74,7 @@ module T::Props
     # implement set-like fields that store a unique-array, but forbid
     # hashes; Custom hash types should be implemented via an emebdded
     # T::Struct (or a subclass like Chalk::ODM::Document) or via T.
-    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
+    sig(:final) { params(val: Object).returns(T::Boolean).checked(:never) }
     def self.valid_serialization?(val)
       case val
       when Array