sorbet-runtime 0.5.11144 → 0.5.11663

data/lib/types/private/types/not_typed.rb

@@ -6,6 +6,10 @@
 class T::Private::Types::NotTyped < T::Types::Base
   ERROR_MESSAGE = "Validation is being done on a `NotTyped`. Please report this bug at https://github.com/sorbet/sorbet/issues"
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     "<NOT-TYPED>"

data/lib/types/private/types/string_holder.rb

@@ -9,6 +9,10 @@ class T::Private::Types::StringHolder < T::Types::Base
     @string = string
   end
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     string

data/lib/types/private/types/type_alias.rb

@@ -9,6 +9,10 @@ module T::Private::Types
       @callable = callable
     end
 
+    def build_type
+      nil
+    end
+
     def aliased_type
       @aliased_type ||= T::Utils.coerce(@callable.call)
     end

data/lib/types/private/types/void.rb

@@ -18,6 +18,10 @@ module T::Private::Types
       freeze
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "<VOID>"

data/lib/types/props/_props.rb

@@ -110,7 +110,7 @@ module T::Props
     #
     # @return [void]
     sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
-    def prop(name, cls, rules={})
+    def prop(name, cls, **rules)
       cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
       decorator.prop_defined(name, cls, rules)
     end
@@ -132,8 +132,8 @@ module T::Props
     end
 
     # Shorthand helper to define a `prop` with `immutable => true`
-    sig {params(name: Symbol, cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
-    def const(name, cls_or_args, args={})
+    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")
       end

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)
 
@@ -429,7 +430,7 @@ class T::Props::Decorator
     else
       nonnil_type = T::Utils.unwrap_nilable(type)
       if nonnil_type
-        T.unsafe(T.nilable(T.all(nonnil_type, T.deprecated_enum(enum))))
+        T.unsafe(T.nilable(T.all(T.unsafe(nonnil_type), T.deprecated_enum(enum))))
       else
         T.unsafe(T.all(T.unsafe(type), T.deprecated_enum(enum)))
       end

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -62,7 +62,9 @@ module T::Props
         source = lazily_defined_methods.fetch(name).call
 
         cls = decorated_class
-        cls.class_eval(source.to_s)
+        T::Configuration.without_ruby_warnings do
+          cls.class_eval(source.to_s)
+        end
         cls.send(:private, name)
       end
 
@@ -117,7 +119,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

@@ -7,13 +7,13 @@ module T::Props::PrettyPrintable
 
   # Override the PP gem with something that's similar, but gives us a hook to do redaction and customization
   def pretty_print(pp)
-    clazz = T.unsafe(T.cast(self, Object).class).decorator
+    klass = T.unsafe(T.cast(self, Object).class).decorator
     multiline = pp.is_a?(PP)
-    pp.group(1, "<#{clazz.inspect_class_with_decoration(self)}", ">") do
-      clazz.all_props.sort.each do |prop|
+    pp.group(1, "<#{klass.inspect_class_with_decoration(self)}", ">") do
+      klass.all_props.sort.each do |prop|
         pp.breakable
-        val = clazz.get(self, prop)
-        rules = clazz.prop_rules(prop)
+        val = klass.get(self, prop)
+        rules = klass.prop_rules(prop)
         pp.text("#{prop}=")
         if (custom_inspect = rules[:inspect])
           inspected = if T::Utils.arity(custom_inspect) == 1
@@ -28,7 +28,7 @@ module T::Props::PrettyPrintable
           val.pretty_print(pp)
         end
       end
-      clazz.pretty_print_extra(self, pp)
+      klass.pretty_print_extra(self, pp)
     end
   end
 
@@ -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

@@ -261,10 +261,31 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def message_with_generated_source_context(error, generated_method, generate_source_method)
-    line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
-    return unless line_label
+    generated_method = generated_method.to_s
+    if error.backtrace_locations
+      line_loc = error.backtrace_locations.find {|l| l.base_label == generated_method}
+      return unless line_loc
 
-    line_num = line_label.split(':')[1]&.to_i
+      line_num = line_loc.lineno
+    else
+      label = if RUBY_VERSION >= "3.4"
+        # in 'ClassName#__t_props_generated_serialize'"
+        "##{generated_method}'"
+      else
+        # in `__t_props_generated_serialize'"
+        "in `#{generated_method}'"
+      end
+      line_label = error.backtrace.find {|l| l.end_with?(label)}
+      return unless line_label
+
+      line_num = if line_label.start_with?("(eval)")
+        # (eval):13:in ...
+        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 ...
+        line_label.split(':')[2]&.to_i
+      end
+    end
     return unless line_num
 
     source_lines = self.send(generate_source_method).split("\n")

data/lib/types/struct.rb

@@ -39,7 +39,7 @@ class T::ImmutableStruct < T::InexactStruct
 
   # 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}
-  def self.prop(name, cls, rules={})
+  def self.prop(name, cls, **rules)
     return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
 
     raise "Cannot use `prop` in #{self.name} because it is an immutable struct. Use `const` instead"

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

@@ -21,7 +21,7 @@ module T::Types
       valid?(obj)
     end
 
-    def valid?(obj)
+    define_method(:valid?) do |_obj|
       raise NotImplementedError
     end
 
@@ -33,8 +33,14 @@ 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`.
+    define_method(:build_type) do
+      raise NotImplementedError
+    end
+
     # Equality is based on name, so be sure the name reflects all relevant state when implementing.
-    def name
+    define_method(:name) do
       raise NotImplementedError
     end
 

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})"
@@ -17,7 +21,7 @@ module T::Types
 
     # overrides Base
     def valid?(obj)
-      obj.is_a?(Module) && obj <= @type
+      obj.is_a?(Module) && (obj <= @type || false)
     end
 
     # overrides Base
@@ -28,7 +32,7 @@ module T::Types
       when Simple
         @type.is_a?(other.raw_type)
       when TypedClass
-        true
+        @type.is_a?(other.underlying_class)
       else
         false
       end

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)
@@ -29,7 +33,7 @@ module T::Types
 
     # overrides Base
     def name
-      @name ||= "T.deprecated_enum([#{@values.map(&:inspect).join(', ')}])"
+      @name ||= "T.deprecated_enum([#{@values.map(&:inspect).sort.join(', ')}])"
     end
 
     # overrides Base

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