sorbet-runtime 0.5.10346 → 0.5.10597

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 074fc57d98df52ce1429d736e41df1ea7f3c2ba2fefa7386b07a4529741186c3
-  data.tar.gz: e5fd218bc7085529da5fd85af7e91178998f37b1f9c609d8455802720987414e
+  metadata.gz: 5569102ba150ab771b791b9265fa4e5472793cb90b4d6066b66fbbf180a6b591
+  data.tar.gz: 64e6645c8a45b5623763b43f5141febbbe5623c8de3868d4842086874984aad0
 SHA512:
-  metadata.gz: f9cde98126821f31e5d6ea0b066e5549e53f050f37105538c0817c5c85fd8e6b50e8c625adb712d9593c19bdfde2e3725aa20abadd08bf68d40c363425c1f23b
-  data.tar.gz: a9e31374cfed23b17e4701a354ac91a84415e3860fe03e32c1c660eae59aa707beceebfc877a2c42ebffd94c5d45424709a87f73447b1d2f954a5b5b7ffbd7fe
+  metadata.gz: 3db0e5871eab9001aaaa336cda62ae6d2f951168beb393e8f60b1868ebe4d901753ae191cabb54753b3f85d50e6f2fb85d861352537a286e257b37870e89bd2e
+  data.tar.gz: 70ed5dba4f054c4a68362df8b65060d623762530f18522696eca9ed17ba076cc7ea92c474350ee99acb53db4f856a53088c904ff757ea2e687d1910e82c0cd34

data/lib/sorbet-runtime.rb

@@ -55,6 +55,7 @@ require_relative 'types/private/types/not_typed'
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
 require_relative 'types/private/types/type_alias'
+require_relative 'types/private/types/simple_pair_union'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'

data/lib/types/_types.rb

@@ -130,7 +130,7 @@ module T
   def self.cast(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.cast")
+    Private::Casts.cast(value, type, "T.cast")
   end
 
   # Tells the typechecker to declare a variable of type `type`. Use
@@ -145,7 +145,7 @@ module T
   def self.let(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.let")
+    Private::Casts.cast(value, type, "T.let")
   end
 
   # Tells the type checker to treat `self` in the current block as `type`.
@@ -164,7 +164,7 @@ module T
   def self.bind(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.bind")
+    Private::Casts.cast(value, type, "T.bind")
   end
 
   # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
@@ -174,7 +174,7 @@ module T
   def self.assert_type!(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.assert_type!")
+    Private::Casts.cast(value, type, "T.assert_type!")
   end
 
   # For the static type checker, strips all type information from a value
@@ -221,6 +221,34 @@ module T
     end
   end
 
+  # A convenience method to `raise` with a provided error reason when the argument
+  # is `nil` and return it otherwise.
+  #
+  # Intended to be used as:
+  #
+  #   needs_foo(T.must_because(maybe_gives_foo) {"reason_foo_should_not_be_nil"})
+  #
+  # Equivalent to:
+  #
+  #   foo = maybe_gives_foo
+  #   raise "reason_foo_should_not_be_nil" if foo.nil?
+  #   needs_foo(foo)
+  #
+  # Intended to be used to promise sorbet that a given nilable value happens
+  # to contain a non-nil value at this point.
+  #
+  # `sig {params(arg: T.nilable(A), reason_blk: T.proc.returns(String)).returns(A)}`
+  def self.must_because(arg)
+    return arg if arg
+    return arg if arg == false
+
+    begin
+      raise TypeError.new("Unexpected `nil` because #{yield}")
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must_because', value: arg, type: nil})
+    end
+  end
+
   # A way to ask Sorbet to show what type it thinks an expression has.
   # This can be useful for debugging and checking assumptions.
   # In the runtime, merely returns the value passed in.

data/lib/types/interface_wrapper.rb

@@ -71,6 +71,10 @@ class T::InterfaceWrapper
         target_obj.send(method_name, *args, &blk)
       end
 
+      if singleton_class.respond_to?(:ruby2_keywords, true)
+        singleton_class.send(:ruby2_keywords, method_name)
+      end
+
       if target_obj.singleton_class.public_method_defined?(method_name)
         # no-op, it's already public
       elsif target_obj.singleton_class.protected_method_defined?(method_name)

data/lib/types/private/casts.rb

@@ -3,9 +3,12 @@
 
 module T::Private
   module Casts
-    def self.cast(value, type, cast_method:)
+    def self.cast(value, type, cast_method)
       begin
-        error = T::Utils.coerce(type).error_message_for_obj(value)
+        coerced_type = T::Utils::Private.coerce_and_check_module_types(type, value, true)
+        return value unless coerced_type
+
+        error = coerced_type.error_message_for_obj(value)
         return value unless error
 
         caller_loc = T.must(caller_locations(2..2)).first
@@ -22,7 +25,7 @@ module T::Private
     # there's a lot of shared logic with the above one, but factoring
     # it out like this makes it easier to hopefully one day delete
     # this one
-    def self.cast_recursive(value, type, cast_method:)
+    def self.cast_recursive(value, type, cast_method)
       begin
         error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
         return value unless error

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

@@ -59,8 +59,9 @@ module T::Private::Methods::CallValidation
 
   def self.create_validator_method(mod, original_method, method_sig, original_visibility)
     has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
-      original_method.parameters.all? {|(kind, _name)| kind == :req}
-    ok_for_fast_path = has_fixed_arity && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+      original_method.parameters.all? {|(kind, _name)| kind == :req || kind == :block}
+    can_skip_block_type = method_sig.block_type.nil? || method_sig.block_type.valid?(nil)
+    ok_for_fast_path = has_fixed_arity && can_skip_block_type && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
 
     all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
     simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
@@ -76,6 +77,11 @@ module T::Private::Methods::CallValidation
           create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
         elsif ok_for_fast_path
           create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+        elsif can_skip_block_type
+          # The Ruby VM already validates that any block passed to a method
+          # must be either `nil` or a `Proc` object, so there's no need to also
+          # have sorbet-runtime check that.
+          create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
         else
           create_validator_slow(mod, original_method, method_sig, original_visibility)
         end
@@ -84,6 +90,88 @@ module T::Private::Methods::CallValidation
     end
   end
 
+  def self.create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      CallValidation.validate_call_skip_block_type(self, original_method, method_sig, args, blk)
+    end
+  end
+
+  def self.validate_call_skip_block_type(instance, original_method, method_sig, args, blk)
+    # This method is called for every `sig`. It's critical to keep it fast and
+    # reduce number of allocations that happen here.
+
+    if method_sig.bind
+      message = method_sig.bind.error_message_for_obj(instance)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Bind',
+          nil,
+          method_sig.bind,
+          instance
+        )
+      end
+    end
+
+    # NOTE: We don't bother validating for missing or extra kwargs;
+    # the method call itself will take care of that.
+    method_sig.each_args_value_type(args) do |name, arg, type|
+      message = type.error_message_for_obj(arg)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Parameter',
+          name,
+          type,
+          arg,
+          caller_offset: 2
+        )
+      end
+    end
+
+    # The original method definition allows passing `nil` for the `&blk`
+    # argument, so we do not have to do any method_sig.block_type type checks
+    # of our own.
+
+    # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+    # PRY note:
+    # this code is sig validation code.
+    # Please issue `finish` to step out of it
+
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+
+    # The only type that is allowed to change the return value is `.void`.
+    # It ignores what you returned and changes it to be a private singleton.
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      T::Private::Types::Void::VOID
+    else
+      message = method_sig.return_type.error_message_for_obj(return_value)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Return value',
+          nil,
+          method_sig.return_type,
+          return_value,
+        )
+      end
+      return_value
+    end
+  end
+
   def self.create_validator_slow(mod, original_method, method_sig, original_visibility)
     T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
       CallValidation.validate_call(self, original_method, method_sig, args, blk)
@@ -125,8 +213,19 @@ module T::Private::Methods::CallValidation
       end
     end
 
-    if method_sig.block_type
-      message = method_sig.block_type.error_message_for_obj(blk)
+    # The Ruby VM already checks that `&blk` is either a `Proc` type or `nil`:
+    # https://github.com/ruby/ruby/blob/v2_7_6/vm_args.c#L1150-L1154
+    # And `T.proc` types don't (can't) do any runtime arg checking, so we can
+    # save work by simply checking that `blk` is non-nil (if the method allows
+    # `nil` for the block, it would not have used this validate_call path).
+    unless blk
+      # Have to use `&.` here, because it's technically a public API that
+      # people can _always_ call `validate_call` to validate any signature
+      # (i.e., the faster validators are merely optimizations).
+      # In practice, this only affects the first call to the method (before the
+      # optimized validators have a chance to replace the initial, slow
+      # wrapper).
+      message = method_sig.block_type&.error_message_for_obj(blk)
       if message
         CallValidation.report_error(
           method_sig,

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

@@ -0,0 +1,42 @@
+# 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
+end

data/lib/types/props/decorator.rb

@@ -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

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)

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/serializable.rb

@@ -338,14 +338,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

data/lib/types/types/base.rb

@@ -163,8 +163,12 @@ module T::Types
     # Type equivalence, defined by serializing the type to a string (with
     # `#name`) and comparing the resulting strings for equality.
     def ==(other)
-      (T::Utils.resolve_alias(other).class == T::Utils.resolve_alias(self).class) &&
+      case other
+      when T::Types::Base
         other.name == self.name
+      else
+        false
+      end
     end
 
     alias_method :eql?, :==

data/lib/types/types/enum.rb

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

data/lib/types/types/intersection.rb

@@ -20,7 +20,7 @@ module T::Types
 
     # overrides Base
     def name
-      "T.all(#{@types.map(&:name).sort.join(', ')})"
+      "T.all(#{@types.map(&:name).compact.sort.join(', ')})"
     end
 
     # overrides Base

data/lib/types/types/simple.rb

@@ -52,7 +52,10 @@ module T::Types
     end
 
     def to_nilable
-      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
+      @nilable ||= T::Private::Types::SimplePairUnion.new(
+        self,
+        T::Utils::Nilable::NIL_TYPE,
+      )
     end
 
     module Private

data/lib/types/types/union.rb

@@ -6,6 +6,8 @@ module T::Types
   class Union < Base
     attr_reader :types
 
+    # Don't use Union.new directly, use `Private::Pool.union_of_types`
+    # inside sorbet-runtime and `T.any` elsewhere.
     def initialize(types)
       @types = types.flat_map do |type|
         type = T::Utils.coerce(type)
@@ -20,11 +22,16 @@ module T::Types
 
     # overrides Base
     def name
-      type_shortcuts(@types)
+      # Use the attr_reader here so we can override it in SimplePairUnion
+      type_shortcuts(types)
     end
 
     private def type_shortcuts(types)
       if types.size == 1
+        # We shouldn't generally get here but it's possible if initializing the type
+        # evades Sorbet's static check and we end up on the slow path, or if someone
+        # is using the T:Types::Union constructor directly (the latter possibility
+        # is why we don't just move the `uniq` into `Private::Pool.union_of_types`).
         return types[0].name
       end
       nilable = T::Utils.coerce(NilClass)
@@ -62,27 +69,45 @@ module T::Types
         EMPTY_ARRAY = [].freeze
         private_constant :EMPTY_ARRAY
 
+        # Try to use `to_nilable` on a type to get memoization, or failing that
+        # try to at least use SimplePairUnion to get faster init and typechecking.
+        #
+        # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
+        # in cases where there are duplicate types, nested unions, etc.
+        #
+        # That's ok, because returning is SimplePairUnion an optimization which
+        # isn't necessary for correctness.
+        #
         # @param type_a [T::Types::Base]
         # @param type_b [T::Types::Base]
         # @param types [Array] optional array of additional T::Types::Base instances
         def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
-          if types.empty?
-            # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
-            # in cases where there are duplicate types, nested unions, etc.
-            #
-            # That's ok, because this is an optimization which isn't necessary for
-            # correctness.
-            if type_b == T::Utils::Nilable::NIL_TYPE && type_a.is_a?(T::Types::Simple)
+          if !types.empty?
+            # Slow path
+            return Union.new([type_a, type_b] + types)
+          elsif !type_a.is_a?(T::Types::Simple) || !type_b.is_a?(T::Types::Simple)
+            # Slow path
+            return Union.new([type_a, type_b])
+          end
+
+          begin
+            if type_b == T::Utils::Nilable::NIL_TYPE
               type_a.to_nilable
-            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
+            elsif type_a == T::Utils::Nilable::NIL_TYPE
               type_b.to_nilable
             else
-              Union.new([type_a, type_b])
+              T::Private::Types::SimplePairUnion.new(type_a, type_b)
             end
-          else
-            # This can't be a `T.nilable(<Module>)` case unless there are duplicates,
-            # which is possible but unexpected.
-            Union.new([type_a, type_b] + types)
+          rescue T::Private::Types::SimplePairUnion::DuplicateType
+            # Slow path
+            #
+            # This shouldn't normally be possible due to static checks,
+            # but we can get here if we're constructing a type dynamically.
+            #
+            # Relying on the duplicate check in the constructor has the
+            # advantage that we avoid it when we hit the memoized case
+            # of `to_nilable`.
+            type_a
           end
         end
       end

data/lib/types/utils.rb

@@ -2,29 +2,41 @@
 # typed: true
 
 module T::Utils
+  module Private
+    def self.coerce_and_check_module_types(val, check_val, check_module_type)
+      if val.is_a?(T::Types::Base)
+        if val.is_a?(T::Private::Types::TypeAlias)
+          val.aliased_type
+        else
+          val
+        end
+      elsif val.is_a?(Module)
+        if check_module_type && check_val.is_a?(val)
+          nil
+        else
+          T::Types::Simple::Private::Pool.type_for_module(val)
+        end
+      elsif val.is_a?(::Array)
+        T::Types::FixedArray.new(val)
+      elsif val.is_a?(::Hash)
+        T::Types::FixedHash.new(val)
+      elsif val.is_a?(T::Private::Methods::DeclBuilder)
+        T::Private::Methods.finalize_proc(val.decl)
+      elsif val.is_a?(::T::Enum)
+        T::Types::TEnum.new(val)
+      elsif val.is_a?(::String)
+        raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
+              "class/module, or an array. Got a String with value `#{val}`."
+      else
+        raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
+              "class/module, or an array. Got a `#{val.class}`."
+      end
+    end
+  end
+
   # Used to convert from a type specification to a `T::Types::Base`.
   def self.coerce(val)
-    if val.is_a?(T::Private::Types::TypeAlias)
-      val.aliased_type
-    elsif val.is_a?(T::Types::Base)
-      val
-    elsif val.is_a?(Module)
-      T::Types::Simple::Private::Pool.type_for_module(val)
-    elsif val.is_a?(::Array)
-      T::Types::FixedArray.new(val)
-    elsif val.is_a?(::Hash)
-      T::Types::FixedHash.new(val)
-    elsif val.is_a?(T::Private::Methods::DeclBuilder)
-      T::Private::Methods.finalize_proc(val.decl)
-    elsif val.is_a?(::T::Enum)
-      T::Types::TEnum.new(val)
-    elsif val.is_a?(::String)
-      raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
-            "class/module, or an array. Got a String with value `#{val}`."
-    else
-      raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
-            "class/module, or an array. Got a `#{val.class}`."
-    end
+    Private.coerce_and_check_module_types(val, nil, false)
   end
 
   # Dynamically confirm that `value` is recursively a valid value of
@@ -32,7 +44,7 @@ module T::Utils
   # in some cases this runtime check can be very expensive, especially
   # with large collections of objects.
   def self.check_type_recursive!(value, type)
-    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
+    T::Private::Casts.cast_recursive(value, type, "T.check_type_recursive!")
   end
 
   # Returns the set of all methods (public, protected, private) defined on a module or its

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.10346
+  version: 0.5.10597
 platform: ruby
 authors:
 - Stripe
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-18 00:00:00.000000000 Z
+date: 2022-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.5.3
 description: Sorbet's runtime type checking component
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -189,6 +189,7 @@ files:
 - lib/types/private/runtime_levels.rb
 - lib/types/private/sealed.rb
 - lib/types/private/types/not_typed.rb
+- lib/types/private/types/simple_pair_union.rb
 - lib/types/private/types/string_holder.rb
 - lib/types/private/types/type_alias.rb
 - lib/types/private/types/void.rb
@@ -245,7 +246,7 @@ licenses:
 - Apache-2.0
 metadata:
   source_code_uri: https://github.com/sorbet/sorbet
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -253,15 +254,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Sorbet runtime
 test_files: []