sorbet-runtime 0.5.10470 → 0.5.10473

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 379d84e84abe1b5c02ec69fa64d931ad61c1b8d52e9f9fc03dc4123c37f3299f
-  data.tar.gz: 3531d39402cd628392b8a17a80c207fcfc0ac3a82c3409e6445da8178fc87fc9
+  metadata.gz: b189a0adf5472e2cae48a050abe2697c03c44048fd3c59b1f104928ed09771d2
+  data.tar.gz: 7aa59c471cf94a8539c610c96b11f36884da152d2b6e37e6f8fb630c781b51fb
 SHA512:
-  metadata.gz: edd9ae63bc0220474cf4210514ed2563e7b77eab79704a9e845f23d8a1023ae13238159bddba0174de7467f2dffc05757c4c346a0a4fa0fc5605ffb571b78849
-  data.tar.gz: bb5e4c7796c5270f49e1b935ae4627c2e6891f2b39eb4adca3421964c8819e7c61e77fa1c2ae590d38810dc5936dd391dce13447565e508ce06179f53167bf65
+  metadata.gz: 8cfcd118c9529eb878a9838deb129d246c7594030553a448116b6f6c30250476367aa2a19ff3b555ba58398b25827fbb7d3d82c45ef267d01076f6810bdcf95d
+  data.tar.gz: 8848028f5f9dd560ce4600a8ff8ead2bf9eb05dc969897bc714f6a6868e5f73fbb36ed3c73979da0f01ead482d1f4a5c4bb0b1d04edde09190f5ba26f6ed1af8

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.10470
+  version: 0.5.10473
 platform: ruby
 authors:
 - Stripe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2022-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -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