sorbet-runtime 0.4.4667 → 0.5.6189

data/lib/types/props/plugin.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: false
 
 module T::Props::Plugin
   include T::Props
@@ -12,4 +12,26 @@ module T::Props::Plugin
     end
   end
   mixes_in_class_methods(ClassMethods)
+
+  module Private
+    # These need to be non-instance methods so we can use them without prematurely creating the
+    # child decorator in `model_inherited` (see comments there for details).
+    #
+    # The dynamic constant access below forces this file to be `typed: false`
+    def self.apply_class_methods(plugin, target)
+      if plugin.const_defined?('ClassMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::ClassMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::ClassMethods)
+      end
+    end
+
+    def self.apply_decorator_methods(plugin, target)
+      if plugin.const_defined?('DecoratorMethods')
+        # FIXME: This will break preloading, selective test execution, etc if `mod::DecoratorMethods`
+        # is ever defined in a separate file from `mod`.
+        target.extend(plugin::DecoratorMethods)
+      end
+    end
+  end
 end

data/lib/types/props/pretty_printable.rb

@@ -18,9 +18,9 @@ module T::Props::PrettyPrintable
   module DecoratorMethods
     extend T::Sig
 
-    sig {returns(T::Array[Symbol])}
-    def valid_props
-      super + [:inspect]
+    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || key == :inspect
     end
 
     sig do

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    class ApplyDefault
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      # checked(:never) - O(object construction x prop count)
+      sig {returns(SetterFactory::SetterProc).checked(:never)}
+      attr_reader :setter_proc
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(accessor_key, setter_proc)
+        @accessor_key = T.let(accessor_key, Symbol)
+        @setter_proc = T.let(setter_proc, SetterFactory::SetterProc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.returns(T.untyped).checked(:never)}
+      def default; end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {abstract.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance); end
+
+      NO_CLONE_TYPES = T.let([TrueClass, FalseClass, NilClass, Symbol, Numeric, T::Enum].freeze, T::Array[Module])
+
+      # checked(:never) - Rules hash is expensive to check
+      sig {params(cls: Module, rules: T::Hash[Symbol, T.untyped]).returns(T.nilable(ApplyDefault)).checked(:never)}
+      def self.for(cls, rules)
+        accessor_key = rules.fetch(:accessor_key)
+        setter = rules.fetch(:setter_proc)
+
+        if rules.key?(:factory)
+          ApplyDefaultFactory.new(cls, rules.fetch(:factory), accessor_key, setter)
+        elsif rules.key?(:default)
+          default = rules.fetch(:default)
+          case default
+          when *NO_CLONE_TYPES
+            return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+          when String
+            if default.frozen?
+              return ApplyPrimitiveDefault.new(default, accessor_key, setter)
+            end
+          when Array
+            if default.empty? && default.class == Array
+              return ApplyEmptyArrayDefault.new(accessor_key, setter)
+            end
+          when Hash
+            if default.empty? && default.default.nil? && T.unsafe(default).default_proc.nil? && default.class == Hash
+              return ApplyEmptyHashDefault.new(accessor_key, setter)
+            end
+          end
+
+          ApplyComplexDefault.new(default, accessor_key, setter)
+        else
+          nil
+        end
+      end
+    end
+
+    class ApplyFixedDefault < ApplyDefault
+      abstract!
+
+      # checked(:never) - We do this with `T.let` instead
+      sig {params(default: BasicObject, accessor_key: Symbol, setter_proc: SetterFactory::SetterProc).void.checked(:never)}
+      def initialize(default, accessor_key, setter_proc)
+        # FIXME: Ideally we'd check here that the default is actually a valid
+        # value for this field, but existing code relies on the fact that we don't.
+        #
+        # :(
+        #
+        # setter_proc.call(default)
+        @default = T.let(default, BasicObject)
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, default)
+      end
+    end
+
+    class ApplyPrimitiveDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      attr_reader :default
+    end
+
+    class ApplyComplexDefault < ApplyFixedDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        T::Props::Utils.deep_clone_object(@default)
+      end
+    end
+
+    # Special case since it's so common, and a literal `[]` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_array.dup`
+    class ApplyEmptyArrayDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, [])
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Array[T.untyped]).checked(:never)}
+      def default
+        []
+      end
+    end
+
+    # Special case since it's so common, and a literal `{}` is meaningfully
+    # faster than falling back to ApplyComplexDefault or even calling
+    # `some_empty_hash.dup`
+    class ApplyEmptyHashDefault < ApplyDefault
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        instance.instance_variable_set(@accessor_key, {})
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T::Hash[T.untyped, T.untyped]).checked(:never)}
+      def default
+        {}
+      end
+    end
+
+    class ApplyDefaultFactory < ApplyDefault
+      # checked(:never) - We do this with `T.let` instead
+      sig do
+        params(
+          cls: Module,
+          factory: T.any(Proc, Method),
+          accessor_key: Symbol,
+          setter_proc: SetterFactory::SetterProc,
+        )
+        .void
+        .checked(:never)
+      end
+      def initialize(cls, factory, accessor_key, setter_proc)
+        @class = T.let(cls, Module)
+        @factory = T.let(factory, T.any(Proc, Method))
+        super(accessor_key, setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.params(instance: T.all(T::Props::Optional, Object)).void.checked(:never)}
+      def set_default(instance)
+        # Use the actual setter to validate the factory returns a legitimate
+        # value every time
+        instance.instance_exec(default, &@setter_proc)
+      end
+
+      # checked(:never) - O(object construction x prop count)
+      sig {override.returns(T.untyped).checked(:never)}
+      def default
+        @class.class_exec(&@factory)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+
+    # Generates a specialized `deserialize` 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 deserializing 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 DeserializerGenerator
+      extend T::Sig
+
+      # Generate a method that takes a T::Hash[String, T.untyped] representing
+      # serialized props, sets instance variables for each prop found in the
+      # input, and returns the count of we props set (which we can use to check
+      # for unexpected input keys with minimal effect on the fast path).
+      sig do
+        params(
+          props: T::Hash[Symbol, T::Hash[Symbol, T.untyped]],
+          defaults: T::Hash[Symbol, T::Props::Private::ApplyDefault],
+        )
+        .returns(String)
+        .checked(:never)
+      end
+      def self.generate(props, defaults)
+        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])
+
+          transformation = SerdeTransform.generate(
+            T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object)),
+            SerdeTransform::Mode::DESERIALIZE,
+            'val'
+          )
+          transformed_val = if transformation
+            # Rescuing exactly NoMethodError is intended as a temporary hack
+            # to preserve the semantics from before codegen. More generally
+            # we are inconsistent about typechecking on deser and need to decide
+            # our strategy here.
+            <<~RUBY
+              begin
+                #{transformation}
+              rescue NoMethodError => e
+                T::Configuration.soft_assert_handler(
+                  'Deserialization error (probably unexpected stored type)',
+                  storytime: {
+                    klass: self.class,
+                    prop: #{prop.inspect},
+                    value: val,
+                    error: e.message,
+                    notify: 'djudd'
+                  }
+                )
+                val
+              end
+            RUBY
+          else
+            'val'
+          end
+
+          nil_handler = generate_nil_handler(
+            prop: prop,
+            serialized_form: hash_key,
+            default: defaults[prop],
+            nilable_type: T::Props::Utils.optional_prop?(rules),
+            raise_on_nil_write: !!rules[:raise_on_nil_write],
+          )
+
+          <<~RUBY
+            val = hash[#{hash_key.inspect}]
+            #{ivar_name} = if val.nil?
+              found -= 1 unless hash.key?(#{hash_key.inspect})
+              #{nil_handler}
+            else
+              #{transformed_val}
+            end
+          RUBY
+        end
+
+        <<~RUBY
+          def __t_props_generated_deserialize(hash)
+            found = #{stored_props.size}
+            #{parts.join("\n\n")}
+            found
+          end
+        RUBY
+      end
+
+      # This is very similar to what we do in ApplyDefault, but has a few
+      # key differences that mean we don't just re-use the code:
+      #
+      # 1. Where the logic in construction is that we generate a default
+      #    if & only if the prop key isn't present in the input, here we'll
+      #    generate a default even to override an explicit nil, but only
+      #    if the prop is actually required.
+      # 2. Since we're generating raw Ruby source, we can remove a layer
+      #    of indirection for marginally better performance; this seems worth
+      #    it for the common cases of literals and empty arrays/hashes.
+      # 3. We need to care about the distinction between `raise_on_nil_write`
+      #    and actually non-nilable, where new-instance construction doesn't.
+      #
+      # So we fall back to ApplyDefault only when one of the cases just
+      # mentioned doesn't apply.
+      sig do
+        params(
+          prop: Symbol,
+          serialized_form: String,
+          default: T.nilable(ApplyDefault),
+          nilable_type: T::Boolean,
+          raise_on_nil_write: T::Boolean,
+        )
+        .returns(String)
+        .checked(:never)
+      end
+      private_class_method def self.generate_nil_handler(
+        prop:,
+        serialized_form:,
+        default:,
+        nilable_type:,
+        raise_on_nil_write:
+      )
+        if !nilable_type
+          case default
+          when NilClass
+            "self.class.decorator.raise_nil_deserialize_error(#{serialized_form.inspect})"
+          when ApplyPrimitiveDefault
+            literal = default.default
+            case literal
+            when String, Integer, Symbol, Float, TrueClass, FalseClass, NilClass
+              literal.inspect
+            else
+              "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"
+            end
+          when ApplyEmptyArrayDefault
+            '[]'
+          when ApplyEmptyHashDefault
+            '{}'
+          else
+            "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"
+          end
+        elsif raise_on_nil_write
+          "required_prop_missing_from_deserialize(#{prop.inspect})"
+        else
+          'nil'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props
+  module Private
+    module Parse
+      def parse(source)
+        @current_ruby ||= require_parser(:CurrentRuby)
+        @current_ruby.parse(source)
+      end
+
+      def s(type, *children)
+        @node ||= require_parser(:AST, :Node)
+        @node.new(type, children)
+      end
+
+      private def require_parser(*constants)
+        # This is an optional dependency for sorbet-runtime in general,
+        # but is required here
+        require 'parser/current'
+
+        # Hack to work around the static checker thinking the constant is
+        # undefined
+        cls = Kernel.const_get(:Parser, true)
+        while (const = constants.shift)
+          cls = cls.const_get(const, false)
+        end
+        cls
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    module SerdeTransform
+      extend T::Sig
+
+      class Serialize; end
+      private_constant :Serialize
+      class Deserialize; end
+      private_constant :Deserialize
+      ModeType = T.type_alias {T.any(Serialize, Deserialize)}
+      private_constant :ModeType
+
+      module Mode
+        SERIALIZE = T.let(Serialize.new.freeze, Serialize)
+        DESERIALIZE = T.let(Deserialize.new.freeze, Deserialize)
+      end
+
+      NO_TRANSFORM_TYPES = T.let(
+        [TrueClass, FalseClass, NilClass, Symbol, String].freeze,
+        T::Array[Module],
+      )
+      private_constant :NO_TRANSFORM_TYPES
+
+      sig do
+        params(
+          type: T::Types::Base,
+          mode: ModeType,
+          varname: String,
+        )
+        .returns(T.nilable(String))
+        .checked(:never)
+      end
+      def self.generate(type, mode, varname)
+        case type
+        when T::Types::TypedArray
+          inner = generate(type.type, mode, 'v')
+          if inner.nil?
+            "#{varname}.dup"
+          else
+            "#{varname}.map {|v| #{inner}}"
+          end
+        when T::Types::TypedSet
+          inner = generate(type.type, mode, 'v')
+          if inner.nil?
+            "#{varname}.dup"
+          else
+            "Set.new(#{varname}) {|v| #{inner}}"
+          end
+        when T::Types::TypedHash
+          keys = generate(type.keys, mode, 'k')
+          values = generate(type.values, mode, 'v')
+          if keys && values
+            "#{varname}.each_with_object({}) {|(k,v),h| h[#{keys}] = #{values}}"
+          elsif keys
+            "#{varname}.transform_keys {|k| #{keys}}"
+          elsif values
+            "#{varname}.transform_values {|v| #{values}}"
+          else
+            "#{varname}.dup"
+          end
+        when T::Types::Simple
+          raw = type.raw_type
+          if NO_TRANSFORM_TYPES.any? {|cls| raw <= cls}
+            nil
+          elsif raw <= Float
+            case mode
+            when Deserialize then "#{varname}.to_f"
+            when Serialize then nil
+            else T.absurd(mode)
+            end
+          elsif raw <= Numeric
+            nil
+          elsif raw < T::Props::Serializable
+            handle_serializable_subtype(varname, raw, mode)
+          elsif raw.singleton_class < T::Props::CustomType
+            handle_custom_type(varname, T.unsafe(raw), mode)
+          elsif T::Configuration.scalar_types.include?(raw.name)
+            # It's a bit of a hack that this is separate from NO_TRANSFORM_TYPES
+            # and doesn't check inheritance (like `T::Props::CustomType.scalar_type?`
+            # does), but it covers the main use case (pay-server's custom `Boolean`
+            # module) without either requiring `T::Configuration.scalar_types` to
+            # accept modules instead of strings (which produces load-order issues
+            # and subtle behavior changes) or eating the performance cost of doing
+            # an inheritance check by manually crawling a class hierarchy and doing
+            # string comparisons.
+            nil
+          else
+            "T::Props::Utils.deep_clone_object(#{varname})"
+          end
+        when T::Types::Union
+          non_nil_type = T::Utils.unwrap_nilable(type)
+          if non_nil_type
+            inner = generate(non_nil_type, mode, varname)
+            if inner.nil?
+              nil
+            else
+              "#{varname}.nil? ? nil : #{inner}"
+            end
+          elsif type.types.all? {|t| generate(t, mode, varname).nil?}
+            # Handle, e.g., T::Boolean
+            nil
+          else
+            # We currently deep_clone_object if the type was T.any(Integer, Float).
+            # When we get better support for union types (maybe this specific
+            # union type, because it would be a replacement for
+            # Chalk::ODM::DeprecatedNumemric), we could opt to special case
+            # this union to have no specific serde transform (the only reason
+            # why Float has a special case is because round tripping through
+            # JSON might normalize Floats to Integers)
+            "T::Props::Utils.deep_clone_object(#{varname})"
+          end
+        when T::Types::Intersection
+          dynamic_fallback = "T::Props::Utils.deep_clone_object(#{varname})"
+
+          # Transformations for any members of the intersection type where we
+          # know what we need to do and did not have to fall back to the
+          # dynamic deep clone method.
+          #
+          # NB: This deliberately does include `nil`, which means we know we
+          # don't need to do any transforming.
+          inner_known = type.types
+            .map {|t| generate(t, mode, varname)}
+            .reject {|t| t == dynamic_fallback}
+            .uniq
+
+          if inner_known.size != 1
+            # If there were no cases where we could tell what we need to do,
+            # e.g. if this is `T.all(SomethingWeird, WhoKnows)`, just use the
+            # dynamic fallback.
+            #
+            # If there were multiple cases and they weren't consistent, e.g.
+            # if this is `T.all(String, T::Array[Integer])`, the type is probably
+            # bogus/uninhabited, but use the dynamic fallback because we still
+            # don't have a better option, and this isn't the place to raise that
+            # error.
+            dynamic_fallback
+          else
+            # This is probably something like `T.all(String, SomeMarker)` or
+            # `T.all(SomeEnum, T.enum(SomeEnum::FOO))` and we should treat it
+            # like String or SomeEnum even if we don't know what to do with
+            # the rest of the type.
+            inner_known.first
+          end
+        when T::Types::Enum
+          generate(T::Utils.lift_enum(type), mode, varname)
+        else
+          "T::Props::Utils.deep_clone_object(#{varname})"
+        end
+      end
+
+      sig {params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never)}
+      private_class_method def self.handle_serializable_subtype(varname, type, mode)
+        case mode
+        when Serialize
+          "#{varname}.serialize(strict)"
+        when Deserialize
+          type_name = T.must(module_name(type))
+          "#{type_name}.from_hash(#{varname})"
+        else
+          T.absurd(mode)
+        end
+      end
+
+      sig {params(varname: String, type: Module, mode: ModeType).returns(String).checked(:never)}
+      private_class_method def self.handle_custom_type(varname, type, mode)
+        case mode
+        when Serialize
+          "T::Props::CustomType.checked_serialize(#{varname})"
+        when Deserialize
+          type_name = T.must(module_name(type))
+          "#{type_name}.deserialize(#{varname})"
+        else
+          T.absurd(mode)
+        end
+      end
+
+      sig {params(type: Module).returns(T.nilable(String)).checked(:never)}
+      private_class_method def self.module_name(type)
+        T::Configuration.module_name_mangler.call(type)
+      end
+    end
+  end
+end