sorbet-runtime 0.5.12155 → 0.6.12632

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
@@ -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).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

@@ -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

@@ -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/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

@@ -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/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
@@ -121,12 +121,12 @@ 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
-          new_extra.reject {|k, v| old_extra[k] == v}
+          new_extra.reject { |k, v| old_extra[k] == v }
         else
           new_extra
         end
@@ -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).
@@ -195,7 +194,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 +227,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 +262,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 +274,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)")
@@ -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/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|

data/lib/types/props/weak_constructor.rb

@@ -6,7 +6,7 @@ module T::Props::WeakConstructor
   extend T::Sig
 
   # checked(:never) - O(runtime object construction)
-  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  sig { params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never) }
   def initialize(hash={})
     decorator = self.class.decorator
 
@@ -28,7 +28,7 @@ module T::Props::WeakConstructor::DecoratorMethods
   # we'll use to check for any unrecognized input.)
   #
   # checked(:never) - O(runtime object construction)
-  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  sig { params(instance: T::Props::WeakConstructor, 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.
@@ -49,7 +49,7 @@ module T::Props::WeakConstructor::DecoratorMethods
   # we'll use to check for any unrecognized input.)
   #
   # checked(:never) - O(runtime object construction)
-  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  sig { params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never) }
   def construct_props_with_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/sig.rb

@@ -14,7 +14,7 @@ module T::Sig
 
     # At runtime, does nothing, but statically it is treated exactly the same
     # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
-    T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+    T::Sig::WithoutRuntime.sig { params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void }
     def self.sig(arg0=nil, &blk); end # rubocop:disable Lint/DuplicateMethods
 
     $VERBOSE = original_verbose
@@ -23,7 +23,7 @@ module T::Sig
   # Declares a method with type signatures and/or
   # abstract/override/... helpers. See the documentation URL on
   # {T::Helpers}
-  T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  T::Sig::WithoutRuntime.sig { params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void }
   def sig(arg0=nil, &blk)
     T::Private::Methods.declare_sig(self, Kernel.caller_locations(1, 1)&.first, arg0, &blk)
   end

data/lib/types/struct.rb

@@ -30,7 +30,7 @@ class T::ImmutableStruct < T::InexactStruct
   end
 
   # Matches the one in WeakConstructor, but freezes the object
-  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  sig { params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never) }
   def initialize(hash={})
     super
 
@@ -38,7 +38,7 @@ class T::ImmutableStruct < T::InexactStruct
   end
 
   # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
-  sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
+  sig { params(name: Symbol, cls: T.untyped, rules: T.untyped).void }
   def self.prop(name, cls, **rules)
     return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
 

data/lib/types/types/base.rb

@@ -83,27 +83,27 @@ module T::Types
       # Note: order of cases here matters!
       if t1.is_a?(T::Types::Union) # 7, 8, 9
         # this will be incorrect if/when we have Type members
-        return t1.types.all? {|t1_member| t1_member.subtype_of?(t2)}
+        return t1.types.all? { |t1_member| t1_member.subtype_of?(t2) }
       end
 
       if t2.is_a?(T::Types::Intersection) # 2, 5
         # this will be incorrect if/when we have Type members
-        return t2.types.all? {|t2_member| t1.subtype_of?(t2_member)}
+        return t2.types.all? { |t2_member| t1.subtype_of?(t2_member) }
       end
 
       if t2.is_a?(T::Types::Union)
         if t1.is_a?(T::Types::Intersection) # 6
           # dropping either of parts eagerly make subtype test be too strict.
           # we have to try both cases, when we normally try only one
-          return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} ||
-              t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+          return t2.types.any? { |t2_member| t1.subtype_of?(t2_member) } ||
+              t1.types.any? { |t1_member| t1_member.subtype_of?(t2) }
         end
-        return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} # 3
+        return t2.types.any? { |t2_member| t1.subtype_of?(t2_member) } # 3
       end
 
       if t1.is_a?(T::Types::Intersection) # 4
         # this will be incorrect if/when we have Type members
-        return t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+        return t1.types.any? { |t1_member| t1_member.subtype_of?(t2) }
       end
 
       # 1; Start with some special cases

data/lib/types/types/fixed_array.rb

@@ -11,7 +11,7 @@ module T::Types
     end
 
     def types
-      @types ||= @inner_types.map {|type| T::Utils.coerce(type)}
+      @types ||= @inner_types.map { |type| T::Utils.coerce(type) }
     end
 
     def build_type

data/lib/types/types/fixed_hash.rb

@@ -10,7 +10,7 @@ module T::Types
     end
 
     def types
-      @types ||= @inner_types.transform_values {|v| T::Utils.coerce(v)}
+      @types ||= @inner_types.transform_values { |v| T::Utils.coerce(v) }
     end
 
     def build_type
@@ -26,16 +26,16 @@ module T::Types
     # overrides Base
     def recursively_valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if types.any? {|key, type| !type.recursively_valid?(obj[key])}
-      return false if obj.any? {|key, _| !types[key]}
+      return false if types.any? { |key, type| !type.recursively_valid?(obj[key]) }
+      return false if obj.any? { |key, _| !types[key] }
       true
     end
 
     # overrides Base
     def valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if types.any? {|key, type| !type.valid?(obj[key])}
-      return false if obj.any? {|key, _| !types[key]}
+      return false if types.any? { |key, type| !type.valid?(obj[key]) }
+      return false if obj.any? { |key, _| !types[key] }
       true
     end
 
@@ -48,7 +48,7 @@ module T::Types
       when TypedHash
         # warning: covariant hashes
 
-        key1, key2, *keys_rest = types.keys.map {|key| T::Utils.coerce(key.class)}
+        key1, key2, *keys_rest = types.keys.map { |key| T::Utils.coerce(key.class) }
         key_type = if !key2.nil?
           T::Types::Union::Private::Pool.union_of_types(key1, key2, keys_rest)
         elsif key1.nil?

data/lib/types/types/intersection.rb

@@ -32,12 +32,12 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      types.all? {|type| type.recursively_valid?(obj)}
+      types.all? { |type| type.recursively_valid?(obj) }
     end
 
     # overrides Base
     def valid?(obj)
-      types.all? {|type| type.valid?(obj)}
+      types.all? { |type| type.valid?(obj) }
     end
 
     # overrides Base

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