sorbet-runtime 0.4.4667 → 0.5.6189

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+
+    # Generates a specialized `serialize` implementation for a subclass of
+    # T::Props::Serializable.
+    #
+    # The basic idea is that we analyze the props and for each prop, generate
+    # the simplest possible logic as a block of Ruby source, so that we don't
+    # pay the cost of supporting types like T:::Hash[CustomType, SubstructType]
+    # when serializing a simple Integer. Then we join those together,
+    # with a little shared logic to be able to detect when we get input keys
+    # that don't match any prop.
+    module SerializerGenerator
+      extend T::Sig
+
+      sig do
+        params(
+          props: T::Hash[Symbol, T::Hash[Symbol, T.untyped]],
+        )
+        .returns(String)
+        .checked(:never)
+      end
+      def self.generate(props)
+        stored_props = props.reject {|_, rules| rules[:dont_store]}
+        parts = stored_props.map do |prop, rules|
+          # All of these strings should already be validated (directly or
+          # indirectly) in `validate_prop_name`, so we don't bother with a nice
+          # error message, but we double check here to prevent a refactoring
+          # from introducing a security vulnerability.
+          raise unless T::Props::Decorator::SAFE_NAME.match?(prop.to_s)
+
+          hash_key = rules.fetch(:serialized_form)
+          raise unless T::Props::Decorator::SAFE_NAME.match?(hash_key)
+
+          ivar_name = rules.fetch(:accessor_key).to_s
+          raise unless ivar_name.start_with?('@') && T::Props::Decorator::SAFE_NAME.match?(ivar_name[1..-1])
+
+          transformed_val = SerdeTransform.generate(
+            T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),
+            SerdeTransform::Mode::SERIALIZE,
+            ivar_name
+          ) || ivar_name
+
+          nil_asserter =
+            if rules[:fully_optional]
+              ''
+            else
+              "required_prop_missing_from_serialize(#{prop.inspect}) if strict"
+            end
+
+          # Don't serialize values that are nil to save space (both the
+          # nil value itself and the field name in the serialized BSON
+          # document)
+          <<~RUBY
+            if #{ivar_name}.nil?
+              #{nil_asserter}
+            else
+              h[#{hash_key.inspect}] = #{transformed_val}
+            end
+          RUBY
+        end
+
+        <<~RUBY
+          def __t_props_generated_serialize(strict)
+            h = {}
+            #{parts.join("\n\n")}
+            h
+          end
+        RUBY
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    module SetterFactory
+      extend T::Sig
+
+      SetterProc = T.type_alias {T.proc.params(val: T.untyped).void}
+      ValidateProc = T.type_alias {T.proc.params(prop: Symbol, value: T.untyped).void}
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          rules: T::Hash[Symbol, T.untyped]
+        )
+        .returns(SetterProc)
+        .checked(:never)
+      end
+      def self.build_setter_proc(klass, prop, rules)
+        # Our nil check works differently than a simple T.nilable for various
+        # reasons (including the `raise_on_nil_write` setting and the existence
+        # of defaults & factories), so unwrap any T.nilable and do a check
+        # manually.
+        non_nil_type = T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
+        accessor_key = rules.fetch(:accessor_key)
+        validate = rules[:setter_validate]
+
+        # It seems like a bug that this affects the behavior of setters, but
+        # some existing code relies on this behavior
+        has_explicit_nil_default = rules.key?(:default) && rules.fetch(:default).nil?
+
+        # Use separate methods in order to ensure that we only close over necessary
+        # variables
+        if !T::Props::Utils.need_nil_write_check?(rules) || has_explicit_nil_default
+          nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
+        else
+          non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
+        end
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: T::Types::Base,
+          klass: T.all(Module, T::Props::ClassMethods),
+          validate: T.nilable(ValidateProc)
+        )
+        .returns(SetterProc)
+      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
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: T::Types::Base,
+          klass: T.all(Module, T::Props::ClassMethods),
+          validate: T.nilable(ValidateProc),
+        )
+        .returns(SetterProc)
+      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
+      end
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          type: T.any(T::Types::Base, Module),
+          val: T.untyped,
+        )
+        .void
+      end
+      def self.raise_pretty_error(klass, prop, type, val)
+        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')}
+        if caller_loc
+          pretty_message += "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
+        end
+
+        T::Configuration.call_validation_error_handler(
+          nil,
+          message: base_message,
+          pretty_message: pretty_message,
+          kind: 'Parameter',
+          name: prop,
+          type: type,
+          value: val,
+          location: caller_loc,
+        )
+      end
+    end
+  end
+end

data/lib/types/props/serializable.rb

@@ -15,97 +15,37 @@ module T::Props::Serializable
   #   exception if this object has mandatory props with missing
   #   values.
   # @return [Hash] A serialization of this object.
-  def serialize(strict=true)
-    decorator = self.class.decorator
-    h = {}
-
-    decorator.props.each do |prop, rules|
-      hkey = rules[:serialized_form]
-
-      val = decorator.get(self, prop, rules)
-
-      if val.nil? && strict && !rules[:fully_optional]
-        # If the prop was already missing during deserialization, that means the application
-        # code already had to deal with a nil value, which means we wouldn't be accomplishing
-        # much by raising here (other than causing an unnecessary breakage).
-        if self.required_prop_missing_from_deserialize?(prop)
-          T::Configuration.log_info_handler(
-            "chalk-odm: missing required property in serialize",
-            prop: prop, class: self.class.name, id: decorator.get_id(self)
-          )
-        else
-          raise T::Props::InvalidValueError.new("#{self.class.name}.#{prop} not set for non-optional prop")
-        end
-      end
-
-      # Don't serialize values that are nil to save space (both the
-      # nil value itself and the field name in the serialized BSON
-      # document)
-      next if rules[:dont_store] || val.nil?
-
-      if rules[:serializable_subtype]
-        if rules[:type_is_serializable]
-          val = val.serialize(strict)
-        elsif rules[:type_is_array_of_serializable]
-          if (subtype = rules[:serializable_subtype]).is_a?(T::Props::CustomType)
-            val = val.map {|el| el && subtype.serialize(el)}
-          else
-            val = val.map {|el| el && el.serialize(strict)}
-          end
-        elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
-          key_subtype = rules[:serializable_subtype][:keys]
-          value_subtype = rules[:serializable_subtype][:values]
-          if value_subtype.is_a?(T::Props::CustomType)
-            val = val.each_with_object({}) do |(key, value), result|
-              result[key_subtype.serialize(key)] = value && value_subtype.serialize(value)
-            end
-          else
-            val = val.each_with_object({}) do |(key, value), result|
-              result[key_subtype.serialize(key)] = value && value.serialize(strict)
-            end
-          end
-        elsif rules[:type_is_hash_of_serializable_values]
-          value_subtype = rules[:serializable_subtype]
-          if value_subtype.is_a?(T::Props::CustomType)
-            val = val.transform_values {|v| v && value_subtype.serialize(v)}
-          else
-            val = val.transform_values {|v| v && v.serialize(strict)}
-          end
-        elsif rules[:type_is_hash_of_custom_type_keys]
-          key_subtype = rules[:serializable_subtype]
-          val = val.each_with_object({}) do |(key, value), result|
-            result[key_subtype.serialize(key)] = value
-          end
-        end
-      elsif rules[:type_is_custom_type]
-        val = rules[:type].serialize(val)
-
-        unless T::Props::CustomType.valid_serialization?(val, rules[:type])
-          msg = "#{rules[:type]} did not serialize to a valid scalar type. It became a: #{val.class}"
-          if val.is_a?(Hash)
-            msg += "\nIf you want to store a structured Hash, consider using a T::Struct as your type."
-          end
-          raise T::Props::InvalidValueError.new(msg)
-        end
-      end
-
-      needs_clone = rules[:type_needs_clone]
-      if needs_clone
-        if needs_clone == :shallow
-          val = val.dup
-        else
-          val = T::Props::Utils.deep_clone_object(val)
+  def serialize(strict=true) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+    begin
+      h = __t_props_generated_serialize(strict)
+    rescue => e
+      msg = self.class.decorator.message_with_generated_source_context(
+        e,
+        :__t_props_generated_serialize,
+        :generate_serialize_source
+      )
+      if msg
+        begin
+          raise e.class.new(msg)
+        rescue ArgumentError
+          raise TypeError.new(msg)
         end
+      else
+        raise
       end
-
-      h[hkey] = val
     end
 
     h.merge!(@_extra_props) if @_extra_props
-
     h
   end
 
+  private def __t_props_generated_serialize(strict)
+    # No-op; will be overridden if there are any props.
+    #
+    # To see the definition for class `Foo`, run `Foo.decorator.send(:generate_serialize_source)`
+    {}
+  end
+
   # Populates the property values on this object with the values
   # from a hash. In general, prefer to use {.from_hash} to construct
   # a new instance, instead of loading into an existing instance.
@@ -116,108 +56,49 @@ module T::Props::Serializable
   #  the hash contains keys that do not correspond to any known
   #  props on this instance.
   # @return [void]
-  def deserialize(hash, strict=false)
-    decorator = self.class.decorator
-
-    matching_props = 0
-
-    decorator.props.each do |p, rules|
-      hkey = rules[:serialized_form]
-      val = hash[hkey]
-      if val.nil?
-        if T::Props::Utils.required_prop?(rules)
-          val = decorator.get_default(rules, self.class)
-          if val.nil?
-            msg = "Tried to deserialize a required prop from a nil value. It's "\
-              "possible that a nil value exists in the database, so you should "\
-              "provide a `default: or factory:` for this prop (see go/optional "\
-              "for more details). If this is already the case, you probably "\
-              "omitted a required prop from the `fields:` option when doing a "\
-              "partial load."
-            storytime = {prop: hkey, klass: self.class.name}
-
-            # Notify the model owner if it exists, and always notify the API owner.
-            begin
-              if defined?(Opus) && defined?(Opus::Ownership) && decorator.decorated_class < Opus::Ownership
-                T::Configuration.hard_assert_handler(
-                  msg,
-                  storytime: storytime,
-                  project: decorator.decorated_class.get_owner
-                )
-              end
-            ensure
-              T::Configuration.hard_assert_handler(msg, storytime: storytime)
-            end
-          end
-        elsif rules[:need_nil_read_check]
-          self.required_prop_missing_from_deserialize(p)
+  def deserialize(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
+    begin
+      hash_keys_matching_props = __t_props_generated_deserialize(hash)
+    rescue => e
+      msg = self.class.decorator.message_with_generated_source_context(
+        e,
+        :__t_props_generated_deserialize,
+        :generate_deserialize_source
+      )
+      if msg
+        begin
+          raise e.class.new(msg)
+        rescue ArgumentError
+          raise TypeError.new(msg)
         end
-
-        matching_props += 1 if hash.key?(hkey)
       else
-        if (subtype = rules[:serializable_subtype])
-          val =
-            if rules[:type_is_array_of_serializable]
-              if subtype.is_a?(T::Props::CustomType)
-                val.map {|el| el && subtype.deserialize(el)}
-              else
-                val.map {|el| el && subtype.from_hash(el)}
-              end
-            elsif rules[:type_is_hash_of_serializable_values] && rules[:type_is_hash_of_custom_type_keys]
-              key_subtype = subtype[:keys]
-              values_subtype = subtype[:values]
-              if values_subtype.is_a?(T::Props::CustomType)
-                val.each_with_object({}) do |(key, value), result|
-                  result[key_subtype.deserialize(key)] = value && values_subtype.deserialize(value)
-                end
-              else
-                val.each_with_object({}) do |(key, value), result|
-                  result[key_subtype.deserialize(key)] = value && values_subtype.from_hash(value)
-                end
-              end
-            elsif rules[:type_is_hash_of_serializable_values]
-              if subtype.is_a?(T::Props::CustomType)
-                val.transform_values {|v| v && subtype.deserialize(v)}
-              else
-                val.transform_values {|v| v && subtype.from_hash(v)}
-              end
-            elsif rules[:type_is_hash_of_custom_type_keys]
-              val.map do |key, value|
-                [subtype.deserialize(key), value]
-              end.to_h
-            else
-              subtype.from_hash(val)
-            end
-        elsif (needs_clone = rules[:type_needs_clone])
-          val =
-            if needs_clone == :shallow
-              val.dup
-            else
-              T::Props::Utils.deep_clone_object(val)
-            end
-        elsif rules[:type_is_custom_type]
-          val = rules[:type].deserialize(val)
-        end
-
-        matching_props += 1
+        raise
       end
-
-      self.instance_variable_set(rules[:accessor_key], val) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
     end
 
-    # We compute extra_props this way specifically for performance
-    if matching_props < hash.size
-      pbsf = decorator.prop_by_serialized_forms
-      h = hash.reject {|k, _| pbsf.key?(k)}
+    if hash.size > hash_keys_matching_props
+      serialized_forms = self.class.decorator.prop_by_serialized_forms
+      extra = hash.reject {|k, _| serialized_forms.key?(k)}
 
-      if strict
-        raise "Unknown properties for #{self.class.name}: #{h.keys.inspect}"
-      else
-        @_extra_props = h
+      # `extra` could still be empty here if the input matches a `dont_store` prop;
+      # historically, we just ignore those
+      if !extra.empty?
+        if strict
+          raise "Unknown properties for #{self.class.name}: #{extra.keys.inspect}"
+        else
+          @_extra_props = extra
+        end
       end
     end
   end
 
+  private def __t_props_generated_deserialize(hash)
+    # No-op; will be overridden if there are any props.
+    #
+    # To see the definition for class `Foo`, run `Foo.decorator.send(:generate_deserialize_source)`
+    0
+  end
+
   # with() will clone the old object to the new object and merge the specified props to the new object.
   def with(changed_props)
     with_existing_hash(changed_props, existing_hash: self.serialize)
@@ -240,8 +121,8 @@ module T::Props::Serializable
   private def with_existing_hash(changed_props, existing_hash:)
     serialized = existing_hash
     new_val = self.class.from_hash(serialized.merge(recursive_stringify_keys(changed_props)))
-    old_extra = self.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
-    new_extra = new_val.instance_variable_get(:@_extra_props) # rubocop:disable PrisonGuard/NoLurkyInstanceVariableAccess
+    old_extra = self.instance_variable_get(:@_extra_props)
+    new_extra = new_val.instance_variable_get(:@_extra_props)
     if old_extra != new_extra
       difference =
         if old_extra
@@ -254,14 +135,23 @@ module T::Props::Serializable
     new_val
   end
 
-  # @return [T::Boolean] Was this property missing during deserialize?
-  def required_prop_missing_from_deserialize?(prop)
-    return false if @_required_props_missing_from_deserialize.nil?
-    @_required_props_missing_from_deserialize.include?(prop)
+  # Asserts if this property is missing during strict serialize
+  private def required_prop_missing_from_serialize(prop)
+    if @_required_props_missing_from_deserialize&.include?(prop)
+      # If the prop was already missing during deserialization, that means the application
+      # code already had to deal with a nil value, which means we wouldn't be accomplishing
+      # much by raising here (other than causing an unnecessary breakage).
+      T::Configuration.log_info_handler(
+        "chalk-odm: missing required property in serialize",
+        prop: prop, class: self.class.name, id: self.class.decorator.get_id(self)
+      )
+    else
+      raise TypeError.new("#{self.class.name}.#{prop} not set for non-optional prop")
+    end
   end
 
-  # @return Marks this property as missing during deserialize
-  def required_prop_missing_from_deserialize(prop)
+  # Marks this property as missing during deserialize
+  private def required_prop_missing_from_deserialize(prop)
     @_required_props_missing_from_deserialize ||= Set[]
     @_required_props_missing_from_deserialize << prop
     nil
@@ -274,12 +164,13 @@ end
 # NB: This must stay in the same file where T::Props::Serializable is defined due to
 # T::Props::Decorator#apply_plugin; see https://git.corp.stripe.com/stripe-internal/pay-server/blob/fc7f15593b49875f2d0499ffecfd19798bac05b3/chalk/odm/lib/chalk-odm/document_decorator.rb#L716-L717
 module T::Props::Serializable::DecoratorMethods
-  def valid_props
-    super + [
-      :dont_store,
-      :name,
-      :raise_on_nil_write,
-    ]
+  include T::Props::HasLazilySpecializedMethods::DecoratorMethods
+
+  VALID_RULE_KEYS = {dont_store: true, name: true, raise_on_nil_write: true}.freeze
+  private_constant :VALID_RULE_KEYS
+
+  def valid_rule_key?(key)
+    super || VALID_RULE_KEYS[key]
   end
 
   def required_props
@@ -289,7 +180,7 @@ module T::Props::Serializable::DecoratorMethods
   def prop_dont_store?(prop); prop_rules(prop)[:dont_store]; end
   def prop_by_serialized_forms; @class.prop_by_serialized_forms; end
 
-  def from_hash(hash, strict=false)
+  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     raise ArgumentError.new("#{hash.inspect} provided to from_hash") if !(hash && hash.is_a?(Hash))
 
     i = @class.allocate
@@ -310,9 +201,63 @@ module T::Props::Serializable::DecoratorMethods
     rules[:serialized_form] = rules.fetch(:name, prop.to_s)
     res = super
     prop_by_serialized_forms[rules[:serialized_form]] = prop
+    enqueue_lazy_method_definition!(:__t_props_generated_serialize) {generate_serialize_source}
+    enqueue_lazy_method_definition!(:__t_props_generated_deserialize) {generate_deserialize_source}
     res
   end
 
+  private def generate_serialize_source
+    T::Props::Private::SerializerGenerator.generate(props)
+  end
+
+  private def generate_deserialize_source
+    T::Props::Private::DeserializerGenerator.generate(
+      props,
+      props_with_defaults || {},
+    )
+  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
+
+    line_num = line_label.split(':')[1]&.to_i
+    return unless line_num
+
+    source_lines = self.send(generate_source_method).split("\n")
+    previous_blank = source_lines[0...line_num].rindex(&:empty?) || 0
+    next_blank = line_num + (source_lines[line_num..-1]&.find_index(&:empty?) || 0)
+    context = "  #{source_lines[(previous_blank + 1)...next_blank].join("\n  ")}"
+    <<~MSG
+      Error in #{decorated_class.name}##{generated_method}: #{error.message}
+      at line #{line_num-previous_blank-1} in:
+      #{context}
+    MSG
+  end
+
+  def raise_nil_deserialize_error(hkey)
+    msg = "Tried to deserialize a required prop from a nil value. It's "\
+      "possible that a nil value exists in the database, so you should "\
+      "provide a `default: or factory:` for this prop (see go/optional "\
+      "for more details). If this is already the case, you probably "\
+      "omitted a required prop from the `fields:` option when doing a "\
+      "partial load."
+    storytime = {prop: hkey, klass: decorated_class.name}
+
+    # Notify the model owner if it exists, and always notify the API owner.
+    begin
+      if defined?(Opus) && defined?(Opus::Ownership) && decorated_class < Opus::Ownership
+        T::Configuration.hard_assert_handler(
+          msg,
+          storytime: storytime,
+          project: decorated_class.get_owner
+        )
+      end
+    ensure
+      T::Configuration.hard_assert_handler(msg, storytime: storytime)
+    end
+  end
+
   def prop_validate_definition!(name, cls, rules, type)
     result = super
 
@@ -344,7 +289,7 @@ module T::Props::Serializable::DecoratorMethods
   private_constant :EMPTY_EXTRA_PROPS
 
   def extra_props(instance)
-    get(instance, '_extra_props') || EMPTY_EXTRA_PROPS
+    instance.instance_variable_get(:@_extra_props) || EMPTY_EXTRA_PROPS
   end
 
   # @override T::Props::PrettyPrintable
@@ -373,7 +318,7 @@ module T::Props::Serializable::ClassMethods
   # Allocate a new instance and call {#deserialize} to load a new
   # object from a hash.
   # @return [Serializable]
-  def from_hash(hash, strict=false)
+  def from_hash(hash, strict=false) # rubocop:disable Style/OptionalBooleanParameter (changing this API is unfortunately not feasible)
     self.decorator.from_hash(hash, strict)
   end