sorbet-runtime 0.5.10439 → 0.5.11120

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

@@ -6,14 +6,63 @@ module T::Private::Methods::SignatureValidation
   Modes = Methods::Modes
 
   def self.validate(signature)
+    # Constructors in any language are always a bit weird: they're called in a
+    # static context, but their bodies are implemented by instance methods. So
+    # a mix of the rules that apply to instance methods and class methods
+    # apply.
+    #
+    # In languages like Java and Scala, static methods/companion object methods
+    # are never inherited. (In Java it almost looks like you can inherit them,
+    # because `Child.static_parent_method` works, but this method is simply
+    # resolved statically to `Parent.static_parent_method`). Even though most
+    # instance methods overrides have variance checking done, constructors are
+    # not treated like this, because static methods are never
+    # inherited/overridden, and the constructor can only ever be called
+    # indirectly by way of the static method. (Note: this is only a mental
+    # model--there's not actually a static method for the constructor in Java,
+    # there's an `invokespecial` JVM instruction that handles this).
+    #
+    # But Ruby is not like Java: singleton class methods in Ruby *are*
+    # inherited, unlike static methods in Java. In fact, this is similar to how
+    # JavaScript works. TypeScript simply then sidesteps the issue with
+    # structural typing: `typeof Parent` is not compatible with `typeof Child`
+    # if their constructors are different. (In a nominal type system, simply
+    # having Child descend from Parent should be the only factor in determining
+    # whether those types are compatible).
+    #
+    # Flow has nominal subtyping for classes. When overriding (static and
+    # instance) methods in a child class, the overrides must satisfy variance
+    # constraints. But it still carves out an exception for constructors,
+    # because then literally every class would have to have the same
+    # constructor. This is simply unsound. Hack does a similar thing--static
+    # method overrides are checked, but not constructors. Though what Hack
+    # *does* have is a way to opt into override checking for constructors with
+    # a special annotation.
+    #
+    # It turns out, Sorbet already has this special annotation: either
+    # `abstract` or `overridable`. At time of writing, *no* static override
+    # checking happens unless marked with these keywords (though at runtime, it
+    # always happens). Getting the static system to parity with the runtime by
+    # always checking overrides would be a great place to get to one day, but
+    # for now we can take advantage of it by only doing override checks for
+    # constructors if they've opted in.
+    #
+    # (When we get around to more widely checking overrides statically, we will
+    # need to build a matching special case for constructors statically.)
+    #
+    # Note that this breaks with tradition: normally, constructors are not
+    # allowed to be abstract. But that's kind of a side-effect of everything
+    # above: in Java/Scala, singleton class methods are never abstract because
+    # they're not inherited, and this extends to constructors. TypeScript
+    # simply rejects `new klass()` entirely if `klass` is
+    # `typeof AbstractClass`, requiring instead that you write
+    # `{ new(): AbstractClass }`. We may want to consider building some
+    # analogue to `T.class_of` in the future that works like this `{new():
+    # ...}` type.
     if signature.method_name == :initialize && signature.method.owner.is_a?(Class)
-      # Constructors are special. They look like overrides in terms of a super_method existing,
-      # but in practice, you never call them polymorphically. Conceptually, they're standard
-      # methods (this is consistent with how they're treated in other languages, e.g. Java)
-      if signature.mode != Modes.standard
-        raise "`initialize` should not use `.abstract` or `.implementation` or any other inheritance modifiers."
+      if signature.mode == Modes.standard
+        return
       end
-      return
     end
 
     super_method = signature.method.super_method
@@ -59,6 +108,19 @@ module T::Private::Methods::SignatureValidation
     case signature.mode
     when *Modes::OVERRIDE_MODES
       # Peaceful
+    when Modes.abstract
+      # Either the parent method is abstract, or it's not.
+      #
+      # If it's abstract, we want to allow overriding abstract with abstract to
+      # possibly narrow the type or provide more specific documentation.
+      #
+      # If it's not, then marking this method `abstract` will silently be a no-op.
+      # That's bad and we probably want to report an error, but fixing that
+      # will have to be a separate fix (that bad behavior predates this current
+      # comment, introduced when we fixed the abstract/abstract case).
+      #
+      # Therefore:
+      # Peaceful (mostly)
     when *Modes::NON_OVERRIDE_MODES
       if super_signature.mode == Modes.standard
         # Peaceful

data/lib/types/private/runtime_levels.rb

@@ -53,10 +53,29 @@ module T::Private::RuntimeLevels
     if @has_read_default_checked_level
       raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
     end
+    if !LEVELS.include?(default_checked_level)
+      raise "Invalid `checked` level '#{default_checked_level}'. Use one of: #{LEVELS}."
+    end
+
     @default_checked_level = default_checked_level
   end
 
   def self._toggle_checking_tests(checked)
     @check_tests = checked
   end
+
+  private_class_method def self.set_enable_checking_in_tests_from_environment
+    if ENV['SORBET_RUNTIME_ENABLE_CHECKING_IN_TESTS']
+      enable_checking_in_tests
+    end
+  end
+  set_enable_checking_in_tests_from_environment
+
+  private_class_method def self.set_default_checked_level_from_environment
+    level = ENV['SORBET_RUNTIME_DEFAULT_CHECKED_LEVEL']
+    if level
+      self.default_checked_level = level.to_sym
+    end
+  end
+  set_default_checked_level_from_environment
 end

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

@@ -20,4 +20,6 @@ class T::Private::Types::NotTyped < T::Types::Base
   private def subtype_of_single?(other)
     raise ERROR_MESSAGE
   end
+
+  INSTANCE = ::T::Private::Types::NotTyped.new.freeze
 end

data/lib/types/private/types/simple_pair_union.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# typed: true
+
+# Specialization of Union for the common case of the union of two simple types.
+#
+# This covers e.g. T.nilable(SomeModule), T.any(Integer, Float), and T::Boolean.
+class T::Private::Types::SimplePairUnion < T::Types::Union
+  class DuplicateType < RuntimeError; end
+
+  # @param type_a [T::Types::Simple]
+  # @param type_b [T::Types::Simple]
+  def initialize(type_a, type_b)
+    if type_a == type_b
+      raise DuplicateType.new("#{type_a} == #{type_b}")
+    end
+
+    @raw_a = type_a.raw_type
+    @raw_b = type_b.raw_type
+  end
+
+  # @override Union
+  def recursively_valid?(obj)
+    obj.is_a?(@raw_a) || obj.is_a?(@raw_b)
+  end
+
+  # @override Union
+  def valid?(obj)
+    obj.is_a?(@raw_a) || obj.is_a?(@raw_b)
+  end
+
+  # @override Union
+  def types
+    # We reconstruct the simple types rather than just storing them because
+    # (1) this is normally not a hot path and (2) we want to keep the instance
+    # variable count <= 3 so that we can fit in a 40 byte heap entry along
+    # with object headers.
+    @types ||= [
+      T::Types::Simple::Private::Pool.type_for_module(@raw_a),
+      T::Types::Simple::Private::Pool.type_for_module(@raw_b),
+    ]
+  end
+
+  # overrides Union
+  def unwrap_nilable
+    a_nil = @raw_a.equal?(NilClass)
+    b_nil = @raw_b.equal?(NilClass)
+    if a_nil
+      return types[1]
+    end
+    if b_nil
+      return types[0]
+    end
+    nil
+  end
+end

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

@@ -3,32 +3,38 @@
 
 # A marking class for when methods return void.
 # Should never appear in types directly.
-class T::Private::Types::Void < T::Types::Base
-  ERROR_MESSAGE = "Validation is being done on an `Void`. Please report this bug at https://github.com/sorbet/sorbet/issues"
+module T::Private::Types
+  class Void < T::Types::Base
+    ERROR_MESSAGE = "Validation is being done on an `Void`. Please report this bug at https://github.com/sorbet/sorbet/issues"
 
-  # The actual return value of `.void` methods.
-  #
-  # Uses `module VOID` because this gives it a readable name when someone
-  # examines it in Pry or with `#inspect` like:
-  #
-  #     T::Private::Types::Void::VOID
-  #
-  module VOID
-    freeze
-  end
+    # The actual return value of `.void` methods.
+    #
+    # Uses `module VOID` because this gives it a readable name when someone
+    # examines it in Pry or with `#inspect` like:
+    #
+    #     T::Private::Types::Void::VOID
+    #
+    module VOID
+      freeze
+    end
 
-  # overrides Base
-  def name
-    "<VOID>"
-  end
+    # overrides Base
+    def name
+      "<VOID>"
+    end
 
-  # overrides Base
-  def valid?(obj)
-    raise ERROR_MESSAGE
-  end
+    # overrides Base
+    def valid?(obj)
+      raise ERROR_MESSAGE
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      raise ERROR_MESSAGE
+    end
 
-  # overrides Base
-  private def subtype_of_single?(other)
-    raise ERROR_MESSAGE
+    module Private
+      INSTANCE = Void.new.freeze
+    end
   end
 end

data/lib/types/props/_props.rb

@@ -139,9 +139,9 @@ module T::Props
       end
 
       if cls_or_args.is_a?(Hash)
-        self.prop(name, cls_or_args.merge(immutable: true))
+        self.prop(name, **cls_or_args.merge(immutable: true))
       else
-        self.prop(name, cls_or_args, args.merge(immutable: true))
+        self.prop(name, cls_or_args, **args.merge(immutable: true))
       end
     end
 

data/lib/types/props/custom_type.rb

@@ -57,12 +57,12 @@ module T::Props
       raise 'Please use "extend", not "include" to attach this module'
     end
 
-    sig(:final) {params(val: Object).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
       # are all classes.
-      klass = T.let(val.class, T.nilable(Class))
+      klass = val.class
       until klass.nil?
         return true if T::Configuration.scalar_types.include?(klass.to_s)
         klass = klass.superclass

data/lib/types/props/decorator.rb

@@ -17,7 +17,7 @@ class T::Props::Decorator
 
   class NoRulesError < StandardError; end
 
-  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules])
+  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules], checked: false)
   private_constant :EMPTY_PROPS
 
   sig {params(klass: T.untyped).void.checked(:never)}
@@ -26,7 +26,7 @@ class T::Props::Decorator
     @class.plugins.each do |mod|
       T::Props::Plugin::Private.apply_decorator_methods(mod, self)
     end
-    @props = T.let(EMPTY_PROPS, T::Hash[Symbol, Rules])
+    @props = T.let(EMPTY_PROPS, T::Hash[Symbol, Rules], checked: false)
   end
 
   # checked(:never) - O(prop accesses)
@@ -50,9 +50,9 @@ class T::Props::Decorator
     override = rules.delete(:override)
 
     if props.include?(prop) && !override
-      raise ArgumentError.new("Attempted to redefine prop #{prop.inspect} that's already defined without specifying :override => true: #{prop_rules(prop)}")
+      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} that doesn't already exist")
+      raise ArgumentError.new("Attempted to override a prop #{prop.inspect} on class #{@class} that doesn't already exist")
     end
 
     @props = @props.merge(prop => rules.freeze).freeze
@@ -79,7 +79,7 @@ class T::Props::Decorator
     extra
     setter_validate
     _tnilable
-  ].map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
+  ].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)}
@@ -205,7 +205,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])
+  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
@@ -247,10 +247,10 @@ class T::Props::Decorator
     nil
   end
 
-  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp)
+  SAFE_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}
+  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}")
@@ -258,7 +258,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)}
+  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
@@ -300,7 +300,9 @@ class T::Props::Decorator
     .checked(:never)
   end
   private def prop_nilable?(cls, rules)
-    T::Utils::Nilable.is_union_with_nilclass(cls) || (cls == T.untyped && rules.key?(:default) && rules[:default].nil?)
+    # NB: `prop` and `const` do not `T::Utils::coerce the type of the prop if it is a `Module`,
+    # hence the bare `NilClass` check.
+    T::Utils::Nilable.is_union_with_nilclass(cls) || ((cls == T.untyped || cls == NilClass) && rules.key?(:default) && rules[:default].nil?)
   end
 
   # checked(:never) - Rules hash is expensive to check
@@ -336,34 +338,34 @@ class T::Props::Decorator
     # Retrive the possible underlying object with T.nilable.
     type = T::Utils::Nilable.get_underlying_type(type)
 
-    sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
-    normalize = T::Configuration.normalize_sensitivity_and_pii_handler
-    if normalize
-      sensitivity_and_pii = normalize.call(sensitivity_and_pii)
-
-      # We check for Class so this is only applied on concrete
-      # documents/models; We allow mixins containing props to not
-      # specify their PII nature, as long as every class into which they
-      # are ultimately included does.
-      #
-      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`'
-        )
+    rules_sensitivity = rules[:sensitivity]
+    sensitivity_and_pii = {sensitivity: rules_sensitivity}
+    if !rules_sensitivity.nil?
+      normalize = T::Configuration.normalize_sensitivity_and_pii_handler
+      if normalize
+        sensitivity_and_pii = normalize.call(sensitivity_and_pii)
+
+        # We check for Class so this is only applied on concrete
+        # documents/models; We allow mixins containing props to not
+        # specify their PII nature, as long as every class into which they
+        # are ultimately included does.
+        #
+        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`'
+          )
+        end
       end
     end
 
-    rules = rules.merge(
-      # TODO: The type of this element is confusing. We should refactor so that
-      # it can be always `type_object` (a PropType) or always `cls` (a Module)
-      type: type,
-      type_object: type_object,
-      accessor_key: "@#{name}".to_sym,
-      sensitivity: sensitivity_and_pii[:sensitivity],
-      pii: sensitivity_and_pii[:pii],
-      # extra arbitrary metadata attached by the code defining this property
-      extra: rules[:extra]&.freeze,
-    )
+    rules[:type] = type
+    rules[:type_object] = type_object
+    rules[:accessor_key] = "@#{name}".to_sym
+    rules[:sensitivity] = sensitivity_and_pii[:sensitivity]
+    rules[:pii] = sensitivity_and_pii[:pii]
+    rules[:extra] = rules[:extra]&.freeze
+
+    # extra arbitrary metadata attached by the code defining this property
 
     validate_not_missing_sensitivity(name, rules)
 
@@ -417,6 +419,7 @@ class T::Props::Decorator
   sig do
     params(type: PropTypeOrClass, enum: T.untyped)
     .returns(T::Types::Base)
+    .checked(:never)
   end
   private def smart_coerce(type, enum:)
     # Backwards compatibility for pre-T::Types style
@@ -469,6 +472,7 @@ class T::Props::Decorator
       redaction: T.untyped,
     )
     .void
+    .checked(:never)
   end
   private def handle_redaction_option(prop_name, redaction)
     redacted_method = "#{prop_name}_redacted"
@@ -490,6 +494,7 @@ class T::Props::Decorator
       valid_type_msg: String,
     )
     .void
+    .checked(:never)
   end
   private def validate_foreign_option(option_sym, foreign, valid_type_msg:)
     if foreign.is_a?(Symbol) || foreign.is_a?(String)
@@ -521,8 +526,8 @@ class T::Props::Decorator
     # here, but we're baking in `allow_direct_mutation` since we
     # *haven't* allowed additional options in the past and want to
     # default to keeping this interface narrow.
+    foreign = T.let(foreign, T.untyped, checked: false)
     @class.send(:define_method, fk_method) do |allow_direct_mutation: nil|
-      foreign = T.let(foreign, T.untyped)
       if foreign.is_a?(Proc)
         resolved_foreign = foreign.call
         if !resolved_foreign.respond_to?(:load)

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -83,7 +83,7 @@ module T::Props
         lazily_defined_methods[name] = blk
 
         cls = decorated_class
-        if cls.method_defined?(name)
+        if cls.method_defined?(name) || cls.private_method_defined?(name)
           # Ruby does not emit "method redefined" warnings for aliased methods
           # (more robust than undef_method that would create a small window in which the method doesn't exist)
           cls.send(:alias_method, name, name)
@@ -117,7 +117,7 @@ module T::Props
       def eagerly_define_lazy_methods!
         return if lazily_defined_methods.empty?
 
-        source = lazily_defined_methods.values.map(&:call).map(&:to_s).join("\n\n")
+        source = "# frozen_string_literal: true\n" + lazily_defined_methods.values.map(&:call).map(&:to_s).join("\n\n")
 
         cls = decorated_class
         cls.class_eval(source)

data/lib/types/props/pretty_printable.rb

@@ -1,18 +1,49 @@
 # frozen_string_literal: true
 # typed: true
+require 'pp'
 
 module T::Props::PrettyPrintable
   include T::Props::Plugin
 
-  # Return a string representation of this object and all of its props
+  # 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
+    multiline = pp.is_a?(PP)
+    pp.group(1, "<#{clazz.inspect_class_with_decoration(self)}", ">") do
+      clazz.all_props.sort.each do |prop|
+        pp.breakable
+        val = clazz.get(self, prop)
+        rules = clazz.prop_rules(prop)
+        pp.text("#{prop}=")
+        if (custom_inspect = rules[:inspect])
+          inspected = if T::Utils.arity(custom_inspect) == 1
+            custom_inspect.call(val)
+          else
+            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(', ')}>")
+        else
+          val.pretty_print(pp)
+        end
+      end
+      clazz.pretty_print_extra(self, pp)
+    end
+  end
+
+  # Return a string representation of this object and all of its props in a single line
   def inspect
-    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self)
+    string = +""
+    PP.singleline_pp(self, string)
+    string
   end
 
-  # Override the PP gem with something that's similar, but gives us a hook
-  # to do redaction
+  # Return a pretty string representation of this object and all of its props
   def pretty_inspect
-    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self, multiline: true)
+    string = +""
+    PP.pp(self, string)
+    string
   end
 
   module DecoratorMethods
@@ -23,85 +54,16 @@ module T::Props::PrettyPrintable
       super || key == :inspect
     end
 
-    sig do
-      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
-      .returns(String)
+    # 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
+    sig {params(instance: T::Props::PrettyPrintable).returns(String)}
+    def inspect_class_with_decoration(instance)
+      T.unsafe(instance).class.to_s
     end
-    def inspect_instance(instance, multiline: false, indent: '  ')
-      components =
-        inspect_instance_components(
-          instance,
-          multiline: multiline,
-          indent: indent
-        )
-          .reject(&:empty?)
-
-      # Not using #<> here as that makes pry highlight these objects
-      # as if they were all comments, whereas this makes them look
-      # like the structured thing they are.
-      if multiline
-        "#{components[0]}:\n" + T.must(components[1..-1]).join("\n")
-      else
-        "<#{components.join(' ')}>"
-      end
-    end
-
-    sig do
-      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
-      .returns(T::Array[String])
-    end
-    private def inspect_instance_components(instance, multiline:, indent:)
-      pretty_props = T.unsafe(self).all_props.map do |prop|
-        [prop, inspect_prop_value(instance, prop, multiline: multiline, indent: indent)]
-      end
-
-      joined_props = join_props_with_pretty_values(
-        pretty_props,
-        multiline: multiline,
-        indent: indent
-      )
 
-      [
-        T.unsafe(self).decorated_class.to_s,
-        joined_props,
-      ]
-    end
-
-    sig do
-      params(instance: T::Props::PrettyPrintable, prop: Symbol, multiline: T::Boolean, indent: String)
-      .returns(String)
-      .checked(:never)
-    end
-    private def inspect_prop_value(instance, prop, multiline:, indent:)
-      val = T.unsafe(self).get(instance, prop)
-      rules = T.unsafe(self).prop_rules(prop)
-      if (custom_inspect = rules[:inspect])
-        if T::Utils.arity(custom_inspect) == 1
-          custom_inspect.call(val)
-        else
-          custom_inspect.call(val, {multiline: multiline, indent: indent})
-        end
-      elsif rules[:sensitivity] && !rules[:sensitivity].empty? && !val.nil?
-        "<REDACTED #{rules[:sensitivity].join(', ')}>"
-      else
-        val.inspect
-      end
-    end
-
-    sig do
-      params(pretty_kvs: T::Array[[Symbol, String]], multiline: T::Boolean, indent: String)
-      .returns(String)
-    end
-    private def join_props_with_pretty_values(pretty_kvs, multiline:, indent: '  ')
-      pairs = pretty_kvs
-        .sort_by {|k, _v| k.to_s}
-        .map {|k, v| "#{k}=#{v}"}
-
-      if multiline
-        indent + pairs.join("\n#{indent}")
-      else
-        pairs.join(', ')
-      end
-    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}
+    def pretty_print_extra(instance, pp); end
   end
 end

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

@@ -176,7 +176,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

@@ -223,9 +223,10 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def add_prop_definition(prop, rules)
-    rules[:serialized_form] = rules.fetch(:name, prop.to_s)
+    serialized_form = rules.fetch(:name, prop.to_s)
+    rules[:serialized_form] = serialized_form
     res = super
-    prop_by_serialized_forms[rules[:serialized_form]] = prop
+    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}
@@ -338,14 +339,21 @@ module T::Props::Serializable::DecoratorMethods
     end
   end
 
-  # overrides T::Props::PrettyPrintable
-  private def inspect_instance_components(instance, multiline:, indent:)
+  # adds to the default result of T::Props::PrettyPrintable
+  def pretty_print_extra(instance, pp)
+    # This is to maintain backwards compatibility with Stripe's codebase, where only the single line (through `inspect`)
+    # version is expected to add anything extra
+    return if !pp.is_a?(PP::SingleLine)
     if (extra_props = extra_props(instance)) && !extra_props.empty?
-      pretty_kvs = extra_props.map {|k, v| [k.to_sym, v.inspect]}
-      extra = join_props_with_pretty_values(pretty_kvs, multiline: false)
-      super + ["@_extra_props=<#{extra}>"]
-    else
-      super
+      pp.breakable
+      pp.text("@_extra_props=")
+      pp.group(1, "<", ">") do
+        extra_props.each_with_index do |(prop, value), i|
+          pp.breakable unless i.zero?
+          pp.text("#{prop}=")
+          value.pretty_print(pp)
+        end
+      end
     end
   end
 end