sorbet-runtime 0.5.5841

data/lib/types/props/type_validation.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::TypeValidation
+  include T::Props::Plugin
+
+  BANNED_TYPES = [Object, BasicObject, Kernel]
+
+  class UnderspecifiedType < ArgumentError; end
+
+  module DecoratorMethods
+    extend T::Sig
+
+    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || :DEPRECATED_underspecified_type == key
+    end
+
+    sig do
+      params(
+        name: T.any(Symbol, String),
+        _cls: Module,
+        rules: T::Hash[Symbol, T.untyped],
+        type: T.any(T::Types::Base, Module)
+      )
+      .void
+    end
+    def prop_validate_definition!(name, _cls, rules, type)
+      super
+
+      if !rules[:DEPRECATED_underspecified_type]
+        validate_type(type, field_name: name)
+      elsif rules[:DEPRECATED_underspecified_type] && find_invalid_subtype(type).nil?
+        raise ArgumentError.new("DEPRECATED_underspecified_type set unnecessarily for #{@class.name}.#{name} - #{type} is a valid type")
+      end
+    end
+
+    sig do
+      params(
+        type: T::Types::Base,
+        field_name: T.any(Symbol, String),
+      )
+      .void
+    end
+    private def validate_type(type, field_name:)
+      if (invalid_subtype = find_invalid_subtype(type))
+        raise UnderspecifiedType.new(type_error_message(invalid_subtype, field_name, type))
+      end
+    end
+
+    # Returns an invalid type, if any, found in the given top-level type.
+    # This might be the type itself, if it is e.g. "Object", or might be
+    # a subtype like the type of the values of a typed hash.
+    #
+    # If the type is fully valid, returns nil.
+    #
+    # checked(:never) - called potentially many times recursively
+    sig {params(type: T::Types::Base).returns(T.nilable(T::Types::Base)).checked(:never)}
+    private def find_invalid_subtype(type)
+      case type
+      when T::Types::TypedEnumerable
+        find_invalid_subtype(type.type)
+      when T::Types::FixedHash
+        type.types.values.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+      when T::Types::Union, T::Types::FixedArray
+        # `T.any` is valid if all of the members are valid
+        type.types.map {|subtype| find_invalid_subtype(subtype)}.compact.first
+      when T::Types::Intersection
+        # `T.all` is valid if at least one of the members is valid
+        invalid = type.types.map {|subtype| find_invalid_subtype(subtype)}.compact
+        if invalid.length == type.types.length
+          invalid.first
+        else
+          nil
+        end
+      when T::Types::Enum, T::Types::ClassOf
+        nil
+      when T::Private::Types::TypeAlias
+        find_invalid_subtype(type.aliased_type)
+      when T::Types::Simple
+        # TODO Could we manage to define a whitelist, consisting of something
+        # like primitives, subdocs, DataInterfaces, and collections/enums/unions
+        # thereof?
+        if BANNED_TYPES.include?(type.raw_type)
+          type
+        else
+          nil
+        end
+      else
+        type
+      end
+    end
+
+    sig do
+      params(
+        type: T::Types::Base,
+        field_name: T.any(Symbol, String),
+        orig_type: T::Types::Base,
+      )
+      .returns(String)
+    end
+    private def type_error_message(type, field_name, orig_type)
+      msg_prefix = "#{@class.name}.#{field_name}: #{orig_type} is invalid in prop definition"
+      if type == orig_type
+        "#{msg_prefix}. Please choose a more specific type (T.untyped and ~equivalents like Object are banned)."
+      else
+        "#{msg_prefix}. Please choose a subtype more specific than #{type} (T.untyped and ~equivalents like Object are banned)."
+      end
+    end
+  end
+end

data/lib/types/props/utils.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Props::Utils
+  # Deep copy an object. The object must consist of Ruby primitive
+  # types and Hashes and Arrays.
+  def self.deep_clone_object(what, freeze: false)
+    result = case what
+    when true
+      true
+    when false
+      false
+    when Symbol, NilClass, Numeric
+      what
+    when Array
+      what.map {|v| deep_clone_object(v, freeze: freeze)}
+    when Hash
+      h = what.class.new
+      what.each do |k, v|
+        k.freeze if freeze
+        h[k] = deep_clone_object(v, freeze: freeze)
+      end
+      h
+    when Regexp
+      what.dup
+    when T::Enum
+      what
+    else
+      what.clone
+    end
+    freeze ? result.freeze : result
+  end
+
+  # The prop_rules indicate whether we should check for reading a nil value for the prop/field.
+  # This is mostly for the compatibility check that we allow existing documents carry some nil prop/field.
+  def self.need_nil_read_check?(prop_rules)
+    # . :on_load allows nil read, but we need to check for the read for future writes
+    prop_rules[:optional] == :on_load || prop_rules[:raise_on_nil_write]
+  end
+
+  # The prop_rules indicate whether we should check for writing a nil value for the prop/field.
+  def self.need_nil_write_check?(prop_rules)
+    need_nil_read_check?(prop_rules) || T::Props::Utils.required_prop?(prop_rules)
+  end
+
+  def self.required_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !prop_rules[:_tnilable]
+  end
+
+  def self.optional_prop?(prop_rules)
+    # Clients should never reference :_tnilable as the implementation can change.
+    !!prop_rules[:_tnilable]
+  end
+
+  def self.merge_serialized_optional_rule(prop_rules)
+    {'_tnilable' => true}.merge(prop_rules.merge('_tnilable' => true))
+  end
+end

data/lib/types/props/weak_constructor.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Props::WeakConstructor
+  include T::Props::Optional
+  extend T::Sig
+
+  # checked(:never) - O(runtime object construction)
+  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  def initialize(hash={})
+    decorator = self.class.decorator
+
+    hash_keys_matching_props = decorator.construct_props_with_defaults(self, hash) +
+      decorator.construct_props_without_defaults(self, hash)
+
+    if hash_keys_matching_props < hash.size
+      raise ArgumentError.new("#{self.class}: Unrecognized properties: #{(hash.keys - decorator.props.keys).join(', ')}")
+    end
+  end
+end
+
+module T::Props::WeakConstructor::DecoratorMethods
+  extend T::Sig
+
+  # Set values for all props that have no defaults. Ignore any not present.
+  #
+  # @return [Integer] A count of props that we successfully initialized (which
+  # we'll use to check for any unrecognized input.)
+  #
+  # checked(:never) - O(runtime object construction)
+  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  def construct_props_without_defaults(instance, hash)
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_without_defaults&.each_pair do |p, setter_proc|
+      if hash.key?(p)
+        instance.instance_exec(hash[p], &setter_proc)
+        result += 1
+      end
+    end
+    result
+  end
+
+  # Set values for all props that have defaults. Use the default if and only if
+  # the prop key isn't in the input.
+  #
+  # @return [Integer] A count of props that we successfully initialized (which
+  # we'll use to check for any unrecognized input.)
+  #
+  # checked(:never) - O(runtime object construction)
+  sig {params(instance: T::Props::WeakConstructor, hash: T::Hash[Symbol, T.untyped]).returns(Integer).checked(:never)}
+  def construct_props_with_defaults(instance, hash)
+    # Use `each_pair` rather than `count` because, as of Ruby 2.6, the latter delegates to Enumerator
+    # and therefore allocates for each entry.
+    result = 0
+    @props_with_defaults&.each_pair do |p, default_struct|
+      if hash.key?(p)
+        instance.instance_exec(hash[p], &default_struct.setter_proc)
+        result += 1
+      else
+        default_struct.set_default(instance)
+      end
+    end
+    result
+  end
+end

data/lib/types/runtime_profiled.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+#
+# From the static system, T::Utils::RuntimeProfiled is T.untyped.
+#
+# But from the runtime system, it's a random class (specifically, a class that
+# normal programs currently don't have any instances of).
+#
+# Thus, T::Utils::RuntimeProfiled can be used to introduce runtime-only type
+# errors. This seems like a bad idea, but it's not. It can be used to gather
+# runtime type information from running code via a custom T::Configuration
+# handler.
+#
+# This process has only ever been used at Stripe, and is likely to have rough
+# edges. If you've managed to find your way here and you're curious to try it,
+# please chat with us on Slack. There are no docs.
+#
+# See also: the --suggest-runtime-profiled flag to sorbet.
+#
+
+module T; end
+module T::Utils; end
+class T::Utils::RuntimeProfiled; end

data/lib/types/sig.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Used as a mixin to any class so that you can call `sig`.
+# Docs at https://sorbet.org/docs/sigs
+module T::Sig
+  module WithoutRuntime
+    # At runtime, does nothing, but statically it is treated exactly the same
+    # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
+    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+
+    original_verbose = $VERBOSE
+    $VERBOSE = false
+
+    # At runtime, does nothing, but statically it is treated exactly the same
+    # as T::Sig#sig. Only use it in cases where you can't use T::Sig#sig.
+    T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+    def self.sig(arg0=nil, &blk); end # rubocop:disable PrisonGuard/BanBuiltinMethodOverride, Lint/DuplicateMethods
+
+    $VERBOSE = original_verbose
+  end
+
+  # Declares a method with type signatures and/or
+  # abstract/override/... helpers. See the documentation URL on
+  # {T::Helpers}
+  T::Sig::WithoutRuntime.sig {params(arg0: T.nilable(Symbol), blk: T.proc.bind(T::Private::Methods::DeclBuilder).void).void}
+  def sig(arg0=nil, &blk) # rubocop:disable PrisonGuard/BanBuiltinMethodOverride
+    T::Private::Methods.declare_sig(self, arg0, &blk)
+  end
+end

data/lib/types/struct.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: true
+
+class T::InexactStruct
+  include T::Props
+  include T::Props::Serializable
+  include T::Props::Constructor
+end
+
+class T::Struct < T::InexactStruct
+  def self.inherited(subclass)
+    super(subclass)
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
+      super(s)
+      raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
+    end
+  end
+end

data/lib/types/types/attached_class.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Modeling AttachedClass properly at runtime would require additional
+  # tracking, so at runtime we permit all values and rely on the static checker.
+  # As AttachedClass is modeled statically as a type member on every singleton
+  # class, this is consistent with the runtime behavior for all type members.
+  class AttachedClassType < Base
+
+    def initialize(); end
+
+    # @override Base
+    def name
+      "AttachedClass"
+    end
+
+    # @override Base
+    def valid?(obj)
+      true
+    end
+
+    # @override Base
+    private def subtype_of_single?(other)
+      case other
+      when AttachedClassType
+        true
+      else
+        false
+      end
+    end
+
+    module Private
+      INSTANCE = AttachedClassType.new.freeze
+    end
+  end
+end

data/lib/types/types/base.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class Base
+    def self.method_added(method_name)
+      super(method_name)
+      # What is now `subtype_of_single?` used to be named `subtype_of?`. Make sure people don't
+      # override the wrong thing.
+      #
+      # NB: Outside of T::Types, we would enforce this by using `sig` and not declaring the method
+      # as overridable, but doing so here would result in a dependency cycle.
+      if method_name == :subtype_of? && self != T::Types::Base
+        raise "`subtype_of?` should not be overridden. You probably want to override " \
+              "`subtype_of_single?` instead."
+      end
+    end
+
+    def valid?(obj)
+      raise NotImplementedError
+    end
+
+    # @return [T::Boolean] This method must be implemented to return whether the subclass is a subtype
+    # of `type`. This should only be called by `subtype_of?`, which guarantees that `type` will be
+    # a "single" type, by which we mean it won't be a Union or an Intersection (c.f.
+    # `isSubTypeSingle` in sorbet).
+    private def subtype_of_single?(type)
+      raise NotImplementedError
+    end
+
+    # Equality is based on name, so be sure the name reflects all relevant state when implementing.
+    def name
+      raise NotImplementedError
+    end
+
+    # Mirrors ruby_typer::core::Types::isSubType
+    # See https://git.corp.stripe.com/stripe-internal/ruby-typer/blob/9fc8ed998c04ac0b96592ae6bb3493b8a925c5c1/core/types/subtyping.cc#L912-L950
+    #
+    # This method cannot be overridden (see `method_added` above).
+    # Subclasses only need to implement `subtype_of_single?`).
+    def subtype_of?(t2)
+      t1 = self
+
+      if t2.is_a?(T::Private::Types::TypeAlias)
+        t2 = t2.aliased_type
+      end
+
+      if t1.is_a?(T::Private::Types::TypeAlias)
+        return t1.aliased_type.subtype_of?(t2)
+      end
+
+      # pairs to cover: 1  (_, _)
+      #                 2  (_, And)
+      #                 3  (_, Or)
+      #                 4  (And, _)
+      #                 5  (And, And)
+      #                 6  (And, Or)
+      #                 7  (Or, _)
+      #                 8  (Or, And)
+      #                 9  (Or, Or)
+
+      # Note: order of cases here matters!
+      if t1.is_a?(T::Types::Union) # 7, 8, 9
+        # this will be incorrect if/when we have Type members
+        return t1.types.all? {|t1_member| t1_member.subtype_of?(t2)}
+      end
+
+      if t2.is_a?(T::Types::Intersection) # 2, 5
+        # this will be incorrect if/when we have Type members
+        return t2.types.all? {|t2_member| t1.subtype_of?(t2_member)}
+      end
+
+      if t2.is_a?(T::Types::Union)
+        if t1.is_a?(T::Types::Intersection) # 6
+          # dropping either of parts eagerly make subtype test be too strict.
+          # we have to try both cases, when we normally try only one
+          return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} ||
+              t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+        end
+        return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} # 3
+      end
+
+      if t1.is_a?(T::Types::Intersection) # 4
+        # this will be incorrect if/when we have Type members
+        return t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+      end
+
+      # 1; Start with some special cases
+      if t1.is_a?(T::Private::Types::Void)
+        return t2.is_a?(T::Private::Types::Void)
+      end
+
+      if t1.is_a?(T::Types::Untyped) || t2.is_a?(T::Types::Untyped)
+        return true
+      end
+
+      # Rest of (1)
+      subtype_of_single?(t2)
+    end
+
+    def to_s
+      name
+    end
+
+    def describe_obj(obj)
+      # Would be redundant to print class and value in these common cases.
+      case obj
+      when nil, true, false
+        return "type #{obj.class}"
+      end
+
+      # In rare cases, obj.inspect may fail, or be undefined, so rescue.
+      begin
+        # Default inspect behavior of, eg; `#<Object:0x0...>` is ugly; just print the hash instead, which is more concise/readable.
+        if obj.method(:inspect).owner == Kernel
+          "type #{obj.class} with hash #{obj.hash}"
+        else
+          "type #{obj.class} with value #{T::Utils.string_truncate_middle(obj.inspect, 30, 30)}"
+        end
+      rescue StandardError, SystemStackError
+        "type #{obj.class} with unprintable value"
+      end
+    end
+
+    def error_message_for_obj(obj)
+      if valid?(obj)
+        nil
+      else
+        "Expected type #{self.name}, got #{describe_obj(obj)}"
+      end
+    end
+
+    def validate!(obj)
+      err = error_message_for_obj(obj)
+      raise TypeError.new(err) if err
+    end
+
+    ### Equality methods (necessary for deduping types with `uniq`)
+
+    def hash
+      name.hash
+    end
+
+    def ==(other)
+      (T::Utils.resolve_alias(other).class == T::Utils.resolve_alias(self).class) &&
+        other.name == self.name
+    end
+
+    alias_method :eql?, :==
+  end
+end