sorbet-runtime 0.5.12155 → 0.6.12632

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
@@ -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}"
@@ -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,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/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

data/lib/types/props/decorator.rb

@@ -10,17 +10,33 @@
 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) }
+  OverrideRules = T.type_alias { T::Hash[Symbol, {allow_incompatible: T::Boolean}] }
 
   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)}
+  OVERRIDE_TRUE = T.let({
+    reader: {allow_incompatible: false}.freeze,
+    writer: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_READER = T.let({
+    reader: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_WRITER = T.let({
+    writer: {allow_incompatible: false}.freeze,
+  }.freeze, OverrideRules)
+
+  OVERRIDE_EMPTY = T.let({}.freeze, OverrideRules)
+
+  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,32 +46,30 @@ 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)}
-  def add_prop_definition(prop, rules)
+  sig { params(name: Symbol, rules: Rules).void.checked(:never) }
+  def add_prop_definition(name, rules)
     override = rules.delete(:override)
 
-    if props.include?(prop) && !override
-      raise ArgumentError.new("Attempted to redefine prop #{prop.inspect} on class #{@class} that's already defined without specifying :override => true: #{prop_rules(prop)}")
-    elsif !props.include?(prop) && override
-      raise ArgumentError.new("Attempted to override a prop #{prop.inspect} on class #{@class} that doesn't already exist")
+    if props.include?(name) && !override
+      raise ArgumentError.new("Attempted to redefine prop #{name.inspect} on class #{@class} that's already defined without specifying :override => true: #{prop_rules(name)}")
     end
 
-    @props = @props.merge(prop => rules.freeze).freeze
+    @props = @props.merge(name => rules.freeze).freeze
   end
 
   # Heads up!
@@ -79,16 +93,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 +112,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
@@ -160,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])
@@ -180,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
 
@@ -202,7 +220,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,8 +241,10 @@ class T::Props::Decorator
         "to 'sensitivity:' (in prop #{@class.name}.#{name})")
     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}")
+    if rules.keys.any? { |k| !valid_rule_key?(k) }
+      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)
@@ -245,9 +265,11 @@ 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)}
+  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 +277,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
@@ -302,6 +324,30 @@ class T::Props::Decorator
     T::Utils::Nilable.is_union_with_nilclass(cls) || ((cls == T.untyped || cls == NilClass) && rules.key?(:default) && rules[:default].nil?)
   end
 
+  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))
+  end
+
+  sig(:final) { params(name: Symbol, rules: Rules).void.checked(:never) }
+  private def validate_overrides(name, rules)
+    override = elaborate_override(name, rules[:override])
+
+    return if rules[:without_accessors]
+
+    if override[:reader] && !method_defined_on_ancestor?(name) && !props.include?(name)
+      raise ArgumentError.new("You marked the getter for prop #{name.inspect} as `override`, but the method `#{name}` doesn't exist to be overridden.")
+    end
+
+    # Properly, we should also check whether `props[name]` is immutable, but the old code didn't either.
+    if !rules[:immutable] && override[:writer] && !method_defined_on_ancestor?("#{name}=".to_sym) && !props.include?(name)
+      raise ArgumentError.new("You marked the setter for prop #{name.inspect} as `override`, but the method `#{name}=` doesn't exist to be overridden.")
+    end
+  end
+
   # checked(:never) - Rules hash is expensive to check
   sig do
     params(
@@ -349,7 +395,7 @@ class T::Props::Decorator
         #
         if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !T.unsafe(@class).contains_pii?
           raise ArgumentError.new(
-            'Cannot include a pii prop in a class that declares `contains_no_pii`'
+            "Cannot define pii prop `#{@class}##{name}` because `#{@class}` is `contains_no_pii`"
           )
         end
       end
@@ -364,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)
@@ -381,6 +425,7 @@ class T::Props::Decorator
     rules[:setter_proc] = setter_proc
     rules[:value_validate_proc] = value_validate_proc
 
+    validate_overrides(name, rules)
     add_prop_definition(name, rules)
 
     # NB: using `without_accessors` doesn't make much sense unless you also define some other way to
@@ -392,7 +437,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]
@@ -405,6 +450,7 @@ class T::Props::Decorator
           # Fast path (~4x faster as of Ruby 2.6)
           @class.send(:define_method, "#{name}=", &rules.fetch(:setter_proc))
         end
+
       end
 
       if method(:prop_get).owner != T::Props::Decorator || rules.key?(:ifunset)
@@ -439,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(
@@ -612,7 +629,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))
@@ -627,7 +644,7 @@ class T::Props::Decorator
 
     props.each do |name, rules|
       copied_rules = rules.dup
-      # NB: Calling `child.decorator` here is a timb bomb that's going to give someone a really bad
+      # NB: Calling `child.decorator` here is a time bomb that's going to give someone a really bad
       # time. Any class that defines props and also overrides the `decorator_class` method is going
       # to reach this line before its override take effect, turning it into a no-op.
       child.decorator.add_prop_definition(name, copied_rules)
@@ -656,19 +673,65 @@ class T::Props::Decorator
     end
   end
 
-  sig {params(child: T.all(Module, T::Props::ClassMethods), prop: Symbol).returns(T::Boolean).checked(:never)}
+  sig(:final) do
+    params(key: Symbol, d: T.untyped, out: T::Hash[Symbol, {allow_incompatible: T::Boolean}])
+      .void
+      .checked(:never)
+  end
+  private def elaborate_override_entry(key, d, out)
+    # It's written this way so that `{reader: false}` will omit the entry for `reader` in the
+    # result entirely
+    case d[key]
+    when TrueClass
+      out[key] = {allow_incompatible: false}
+    when Hash
+      out[key] = {allow_incompatible: !!d[key][:allow_incompatible]}
+    end
+  end
+
+  sig(:final) do
+    params(name: Symbol, d: T.untyped)
+      .returns(T::Hash[Symbol, {allow_incompatible: T::Boolean}])
+      .checked(:never)
+  end
+  private def elaborate_override(name, d)
+    return OVERRIDE_TRUE if d == true
+    return OVERRIDE_READER if d == :reader
+    return OVERRIDE_WRITER if d == :writer
+    return OVERRIDE_EMPTY if d == false || d.nil?
+    unless d.is_a?(Hash)
+      raise ArgumentError.new("`override` only accepts `true`, `:reader`, `:writer`, or a Hash in prop #{@class.name}.#{name} (got #{d.class})")
+    end
+
+    # cwong: should we check for bad keys? `sig { override(not_real: true) }` on a normal function
+    # errors statically but not at runtime.
+
+    # XX cwong: this means {reader: false, allow_incompatible: true} will become {allow_incompatible: true},
+    # is that fine?
+    unless (allow_incompatible = d[:allow_incompatible]).nil?
+      return {reader: {allow_incompatible: !!allow_incompatible},
+              writer: {allow_incompatible: !!allow_incompatible}}.to_h
+    end
+
+    result = {}
+    elaborate_override_entry(:reader, d, result)
+    elaborate_override_entry(:writer, d, result)
+    result
+  end
+
+  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,30 +30,30 @@ 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
+      !@lazy_evaluation_disabled
     end
 
     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)