sorbet-runtime 0.5.11144 → 0.5.11264

data/lib/types/props/decorator.rb

@@ -100,10 +100,7 @@ class T::Props::Decorator
   # checked(:never) - potentially O(prop accesses) depending on usage pattern
   sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
   def validate_prop_value(prop, val)
-    # We call `setter_proc` here without binding to an instance, so it'll run
-    # `instance_variable_set` if validation passes, but nothing will care.
-    # We only care about the validation.
-    prop_rules(prop).fetch(:setter_proc).call(val)
+    prop_rules(prop).fetch(:value_validate_proc).call(val)
   end
 
   # For performance, don't use named params here.
@@ -296,7 +293,7 @@ class T::Props::Decorator
       cls: PropTypeOrClass,
       rules: Rules,
     )
-    .void
+    .returns(T.anything)
     .checked(:never)
   end
   private def prop_nilable?(cls, rules)
@@ -335,7 +332,7 @@ class T::Props::Decorator
 
     prop_validate_definition!(name, cls, rules, type_object)
 
-    # Retrive the possible underlying object with T.nilable.
+    # Retrieve the possible underlying object with T.nilable.
     type = T::Utils::Nilable.get_underlying_type(type)
 
     rules_sensitivity = rules[:sensitivity]
@@ -378,7 +375,11 @@ class T::Props::Decorator
       end
     end
 
-    rules[:setter_proc] = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules).freeze
+    setter_proc, value_validate_proc = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules)
+    setter_proc.freeze
+    value_validate_proc.freeze
+    rules[:setter_proc] = setter_proc
+    rules[:value_validate_proc] = value_validate_proc
 
     add_prop_definition(name, rules)
 

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -117,7 +117,9 @@ module T::Props
       def eagerly_define_lazy_methods!
         return if lazily_defined_methods.empty?
 
+        # rubocop:disable Style/StringConcatenation
         source = "# frozen_string_literal: true\n" + lazily_defined_methods.values.map(&:call).map(&:to_s).join("\n\n")
+        # rubocop:enable Style/StringConcatenation
 
         cls = decorated_class
         cls.class_eval(source)

data/lib/types/props/pretty_printable.rb

@@ -55,7 +55,7 @@ module T::Props::PrettyPrintable
     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 overriden
+    # NOTE: This is just to support Stripe's `PrettyPrintableModel` case, and not recommended to be overridden
     sig {params(instance: T::Props::PrettyPrintable).returns(String)}
     def inspect_class_with_decoration(instance)
       T.unsafe(instance).class.to_s

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

@@ -137,7 +137,10 @@ module T::Props
           when ApplyPrimitiveDefault
             literal = default.default
             case literal
-            when String, Integer, Symbol, Float, TrueClass, FalseClass, NilClass
+            # `Float` is intentionally left out here because `.inspect` does not produce the correct code
+            # representation for non-finite values like `Float::INFINITY` and `Float::NAN` and it's not totally
+            # clear that it won't cause issues with floating point precision.
+            when String, Integer, Symbol, TrueClass, FalseClass, NilClass
               literal.inspect
             else
               "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"

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

@@ -7,6 +7,7 @@ module T::Props
       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}
 
       sig do
@@ -15,7 +16,7 @@ module T::Props
           prop: Symbol,
           rules: T::Hash[Symbol, T.untyped]
         )
-        .returns(SetterProc)
+        .returns([SetterProc, ValueValidationProc])
         .checked(:never)
       end
       def self.build_setter_proc(klass, prop, rules)
@@ -55,20 +56,32 @@ module T::Props
           non_nil_type: Module,
           klass: T.all(Module, T::Props::ClassMethods),
         )
-        .returns(SetterProc)
+        .returns([SetterProc, ValueValidationProc])
       end
       private_class_method def self.simple_non_nil_proc(prop, accessor_key, non_nil_type, klass)
-        proc do |val|
-          unless val.is_a?(non_nil_type)
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              T::Utils.coerce(non_nil_type),
-              val,
-            )
-          end
-          instance_variable_set(accessor_key, val)
-        end
+        [
+          proc do |val|
+            unless val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+            instance_variable_set(accessor_key, val)
+          end,
+          proc do |val|
+            unless val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+          end,
+        ]
       end
 
       sig do
@@ -79,27 +92,46 @@ module T::Props
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc)
         )
-        .returns(SetterProc)
+        .returns([SetterProc, ValueValidationProc])
       end
       private_class_method def self.non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
-        proc do |val|
-          # this use of recursively_valid? is intentional: unlike for
-          # methods, we want to make sure data at the 'edge'
-          # (e.g. models that go into databases or structs serialized
-          # from disk) are correct, so we use more thorough runtime
-          # checks there
-          if non_nil_type.recursively_valid?(val)
-            validate&.call(prop, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              non_nil_type,
-              val,
-            )
-          end
-          instance_variable_set(accessor_key, val)
-        end
+        [
+          proc do |val|
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            if non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+            instance_variable_set(accessor_key, val)
+          end,
+          proc do |val|
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            if non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+          end,
+        ]
       end
 
       sig do
@@ -109,24 +141,32 @@ module T::Props
           non_nil_type: Module,
           klass: T.all(Module, T::Props::ClassMethods),
         )
-        .returns(SetterProc)
+        .returns([SetterProc, ValueValidationProc])
       end
       private_class_method def self.simple_nilable_proc(prop, accessor_key, non_nil_type, klass)
-        proc do |val|
-          if val.nil?
-            instance_variable_set(accessor_key, nil)
-          elsif val.is_a?(non_nil_type)
-            instance_variable_set(accessor_key, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              T::Utils.coerce(non_nil_type),
-              val,
-            )
+        [
+          proc do |val|
+            unless val.nil? || val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
             instance_variable_set(accessor_key, val)
-          end
-        end
+          end,
+          proc do |val|
+            unless val.nil? || val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+          end,
+        ]
       end
 
       sig do
@@ -137,30 +177,50 @@ module T::Props
           klass: T.all(Module, T::Props::ClassMethods),
           validate: T.nilable(ValidateProc),
         )
-        .returns(SetterProc)
+        .returns([SetterProc, ValueValidationProc])
       end
       private_class_method def self.nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
-        proc do |val|
-          if val.nil?
-            instance_variable_set(accessor_key, nil)
-          # this use of recursively_valid? is intentional: unlike for
-          # methods, we want to make sure data at the 'edge'
-          # (e.g. models that go into databases or structs serialized
-          # from disk) are correct, so we use more thorough runtime
-          # checks there
-          elsif non_nil_type.recursively_valid?(val)
-            validate&.call(prop, val)
-            instance_variable_set(accessor_key, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              non_nil_type,
-              val,
-            )
-            instance_variable_set(accessor_key, val)
-          end
-        end
+        [
+          proc do |val|
+            if val.nil?
+              instance_variable_set(accessor_key, nil)
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            elsif non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+              instance_variable_set(accessor_key, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+              instance_variable_set(accessor_key, val)
+            end
+          end,
+          proc do |val|
+            if val.nil?
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            elsif non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+          end,
+        ]
       end
 
       sig do

data/lib/types/props/serializable.rb

@@ -264,7 +264,13 @@ module T::Props::Serializable::DecoratorMethods
     line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
     return unless line_label
 
-    line_num = line_label.split(':')[1]&.to_i
+    line_num = if line_label.start_with?("(eval)")
+      # (eval):13:in `__t_props_generated_serialize'
+      line_label.split(':')[1]&.to_i
+    else
+      # (eval at /Users/jez/stripe/sorbet/gems/sorbet-runtime/lib/types/props/has_lazily_specialized_methods.rb:65):13:in `__t_props_generated_serialize'
+      line_label.split(':')[2]&.to_i
+    end
     return unless line_num
 
     source_lines = self.send(generate_source_method).split("\n")

data/lib/types/types/anything.rb

@@ -6,6 +6,10 @@ module T::Types
   class Anything < Base
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.anything"

data/lib/types/types/attached_class.rb

@@ -10,6 +10,10 @@ module T::Types
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.attached_class"

data/lib/types/types/base.rb

@@ -33,6 +33,12 @@ module T::Types
       raise NotImplementedError
     end
 
+    # Force any lazy initialization that this type might need to do
+    # It's unusual to call this directly; you probably want to call it indirectly via `T::Utils.run_all_sig_blocks`.
+    def build_type
+      raise NotImplementedError
+    end
+
     # Equality is based on name, so be sure the name reflects all relevant state when implementing.
     def name
       raise NotImplementedError

data/lib/types/types/class_of.rb

@@ -10,6 +10,10 @@ module T::Types
       @type = type
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.class_of(#{@type})"

data/lib/types/types/enum.rb

@@ -12,6 +12,10 @@ module T::Types
       @values = values
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def valid?(obj)
       @values.member?(obj)

data/lib/types/types/fixed_array.rb

@@ -6,23 +6,30 @@ module T::Types
   # Takes a list of types. Validates each item in an array using the type in the same position
   # in the list.
   class FixedArray < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.map {|type| T::Utils.coerce(type)}
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.map {|type| T::Utils.coerce(type)}
+    end
+
+    def build_type
+      types
+      nil
     end
 
     # overrides Base
     def name
-      "[#{@types.join(', ')}]"
+      "[#{types.join(', ')}]"
     end
 
     # overrides Base
     def recursively_valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
+      if obj.is_a?(Array) && obj.length == types.length
         i = 0
-        while i < @types.length
-          if !@types[i].recursively_valid?(obj[i])
+        while i < types.length
+          if !types[i].recursively_valid?(obj[i])
             return false
           end
           i += 1
@@ -35,10 +42,10 @@ module T::Types
 
     # overrides Base
     def valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
+      if obj.is_a?(Array) && obj.length == types.length
         i = 0
-        while i < @types.length
-          if !@types[i].valid?(obj[i])
+        while i < types.length
+          if !types[i].valid?(obj[i])
             return false
           end
           i += 1
@@ -56,7 +63,7 @@ module T::Types
         # Properly speaking, covariance here is unsound since arrays
         # can be mutated, but sorbet implements covariant tuples for
         # ease of adoption.
-        @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
+        types.size == other.types.size && types.zip(other.types).all? do |t1, t2|
           t1.subtype_of?(t2)
         end
       when TypedArray
@@ -85,7 +92,7 @@ module T::Types
     # overrides Base
     def describe_obj(obj)
       if obj.is_a?(Array)
-        if obj.length == @types.length
+        if obj.length == types.length
           item_classes = obj.map(&:class).join(', ')
           "type [#{item_classes}]"
         else

data/lib/types/types/fixed_hash.rb

@@ -5,30 +5,37 @@ module T::Types
   # Takes a hash of types. Validates each item in a hash using the type in the same position
   # in the list.
   class FixedHash < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.transform_values {|v| T::Utils.coerce(v)}
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.transform_values {|v| T::Utils.coerce(v)}
+    end
+
+    def build_type
+      types
+      nil
     end
 
     # overrides Base
     def name
-      serialize_hash(@types)
+      serialize_hash(types)
     end
 
     # 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
 
@@ -37,7 +44,7 @@ module T::Types
       case other
       when FixedHash
         # Using `subtype_of?` here instead of == would be unsound
-        @types == other.types
+        types == other.types
       when TypedHash
         # warning: covariant hashes
 

data/lib/types/types/intersection.rb

@@ -4,10 +4,12 @@
 module T::Types
   # Takes a list of types. Validates that an object matches all of the types.
   class Intersection < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.flat_map do |type|
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.flat_map do |type|
         type = T::Utils.resolve_alias(type)
         if type.is_a?(Intersection)
           # Simplify nested intersections (mostly so `name` returns a nicer value)
@@ -18,19 +20,24 @@ module T::Types
       end.uniq
     end
 
+    def build_type
+      types
+      nil
+    end
+
     # overrides Base
     def name
-      "T.all(#{@types.map(&:name).compact.sort.join(', ')})"
+      "T.all(#{types.map(&:name).compact.sort.join(', ')})"
     end
 
     # 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/noreturn.rb

@@ -6,6 +6,10 @@ module T::Types
   class NoReturn < Base
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.noreturn"

data/lib/types/types/proc.rb

@@ -8,21 +8,31 @@ module T::Types
   # At present, we only support fixed-arity procs with no optional or
   # keyword arguments.
   class Proc < Base
-    attr_reader :arg_types
-    attr_reader :returns
-
     def initialize(arg_types, returns)
-      @arg_types = {}
-      arg_types.each do |key, raw_type|
-        @arg_types[key] = T::Utils.coerce(raw_type)
+      @inner_arg_types = arg_types
+      @inner_returns = returns
+    end
+
+    def arg_types
+      @arg_types ||= @inner_arg_types.transform_values do |raw_type|
+        T::Utils.coerce(raw_type)
       end
-      @returns = T::Utils.coerce(returns)
+    end
+
+    def returns
+      @returns ||= T::Utils.coerce(@inner_returns)
+    end
+
+    def build_type
+      arg_types
+      returns
+      nil
     end
 
     # overrides Base
     def name
       args = []
-      @arg_types.each do |k, v|
+      arg_types.each do |k, v|
         args << "#{k}: #{v.name}"
       end
       "T.proc.params(#{args.join(', ')}).returns(#{returns})"

data/lib/types/types/self_type.rb

@@ -8,6 +8,10 @@ module T::Types
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.self_type"

data/lib/types/types/simple.rb

@@ -13,13 +13,22 @@ module T::Types
       @raw_type = raw_type
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
       #
       # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
       # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
+      #
+      # Care more about back compat than we do about performance here.
+      # Once 2.6 is well in the rear view mirror, we can replace this.
+      # rubocop:disable Performance/BindCall
       @name ||= (NAME_METHOD.bind(@raw_type).call || @raw_type.name).freeze
+      # rubocop:enable Performance/BindCall
     end
 
     # overrides Base

data/lib/types/types/t_enum.rb

@@ -10,6 +10,10 @@ module T::Types
       @val = val
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       # Strips the #<...> off, just leaving the ...