sorbet-runtime 0.5.11170 → 0.5.11175

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba060f9b7c385ed33f402d9d286ecef808806829a96c3fb48a8b9940778f044
-  data.tar.gz: ffdf68e0a3e45d26c05dca18914eb3d3a45f66311eff018ad05347f32a33ebb6
+  metadata.gz: 01fe1cd8291711ea4e0483c920c7d79344710e14e55807132409bd8afd572e75
+  data.tar.gz: 4c8b7c9d278e6b4320efbf57c87e46d238346fa75bb231cd3572c2f568d3e913
 SHA512:
-  metadata.gz: f3f002fa0707048b8f3a6b7263c1682aeea29aa6f1501e57b26e59fceb6e54fa2b943d54026c25d56847f739cbf5662625ce8d5eb14802b45f1978f3886f23d0
-  data.tar.gz: 1e28fc2f1a65dc7119ea7b1b3f4999cca5c6a7cdf4d2ea0e48f904292b959bbf60dd8bfd94235fe59fc737c430f5b1957536b4c8659d3fb4bfb6ccfb66a17732
+  metadata.gz: cca6ac69e53f520671d1378633f79474c910984bfc0279c4fd366aa8a086cb18bcb6c728b797529c82eb57f884041763d8fcd3f872fd562356347875f98005f6
+  data.tar.gz: e43cb943fb0336c3c436b0a4b25316deccddd6a0c58e05f4c4735097c028c97aed4629e43e589e0d2572e57afec5cec08b6d14b7318633ca4f3bf15c75666038

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

@@ -428,7 +428,7 @@ module T::Private::Methods
     run_sig_block_for_key(method_to_key(method))
   end
 
-  private_class_method def self.run_sig_block_for_key(key)
+  private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
       sig = @signatures_by_method[key]
@@ -451,14 +451,17 @@ module T::Private::Methods
     end
 
     @sig_wrappers.delete(key)
+
+    sig.force_type_init if force_type_init
+
     sig
   end
 
-  def self.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
     loop do
       break if @sig_wrappers.empty?
       key, = @sig_wrappers.first
-      run_sig_block_for_key(key)
+      run_sig_block_for_key(key, force_type_init: force_type_init)
     end
   end
 

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

@@ -245,6 +245,15 @@ class T::Private::Methods::Signature
     "#{@method} at #{loc}"
   end
 
+  def force_type_init
+    @arg_types.each {|_, type| type.build_type}
+    @kwarg_types.each {|_, type| type.build_type}
+    @block_type&.build_type
+    @rest_type&.build_type
+    @keyrest_type&.build_type
+    @return_type.build_type
+  end
+
   EMPTY_LIST = [].freeze
   EMPTY_HASH = {}.freeze
 end

data/lib/types/private/types/not_typed.rb

@@ -6,6 +6,10 @@
 class T::Private::Types::NotTyped < T::Types::Base
   ERROR_MESSAGE = "Validation is being done on a `NotTyped`. Please report this bug at https://github.com/sorbet/sorbet/issues"
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     "<NOT-TYPED>"

data/lib/types/private/types/string_holder.rb

@@ -9,6 +9,10 @@ class T::Private::Types::StringHolder < T::Types::Base
     @string = string
   end
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     string

data/lib/types/private/types/type_alias.rb

@@ -9,6 +9,10 @@ module T::Private::Types
       @callable = callable
     end
 
+    def build_type
+      nil
+    end
+
     def aliased_type
       @aliased_type ||= T::Utils.coerce(@callable.call)
     end

data/lib/types/private/types/void.rb

@@ -18,6 +18,10 @@ module T::Private::Types
       freeze
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "<VOID>"

data/lib/types/types/anything.rb

@@ -6,6 +6,10 @@ module T::Types
   class Anything < Base
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.anything"

data/lib/types/types/attached_class.rb

@@ -10,6 +10,10 @@ module T::Types
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.attached_class"

data/lib/types/types/base.rb

@@ -33,6 +33,12 @@ module T::Types
       raise NotImplementedError
     end
 
+    # Force any lazy initialization that this type might need to do
+    # It's unusual to call this directly; you probably want to call it indirectly via `T::Utils.run_all_sig_blocks`.
+    def build_type
+      raise NotImplementedError
+    end
+
     # Equality is based on name, so be sure the name reflects all relevant state when implementing.
     def name
       raise NotImplementedError

data/lib/types/types/class_of.rb

@@ -10,6 +10,10 @@ module T::Types
       @type = type
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.class_of(#{@type})"

data/lib/types/types/enum.rb

@@ -12,6 +12,10 @@ module T::Types
       @values = values
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def valid?(obj)
       @values.member?(obj)

data/lib/types/types/fixed_array.rb

@@ -6,23 +6,30 @@ module T::Types
   # Takes a list of types. Validates each item in an array using the type in the same position
   # in the list.
   class FixedArray < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.map {|type| T::Utils.coerce(type)}
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.map {|type| T::Utils.coerce(type)}
+    end
+
+    def build_type
+      types
+      nil
     end
 
     # overrides Base
     def name
-      "[#{@types.join(', ')}]"
+      "[#{types.join(', ')}]"
     end
 
     # overrides Base
     def recursively_valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
+      if obj.is_a?(Array) && obj.length == types.length
         i = 0
-        while i < @types.length
-          if !@types[i].recursively_valid?(obj[i])
+        while i < types.length
+          if !types[i].recursively_valid?(obj[i])
             return false
           end
           i += 1
@@ -35,10 +42,10 @@ module T::Types
 
     # overrides Base
     def valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
+      if obj.is_a?(Array) && obj.length == types.length
         i = 0
-        while i < @types.length
-          if !@types[i].valid?(obj[i])
+        while i < types.length
+          if !types[i].valid?(obj[i])
             return false
           end
           i += 1
@@ -56,7 +63,7 @@ module T::Types
         # Properly speaking, covariance here is unsound since arrays
         # can be mutated, but sorbet implements covariant tuples for
         # ease of adoption.
-        @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
+        types.size == other.types.size && types.zip(other.types).all? do |t1, t2|
           t1.subtype_of?(t2)
         end
       when TypedArray
@@ -85,7 +92,7 @@ module T::Types
     # overrides Base
     def describe_obj(obj)
       if obj.is_a?(Array)
-        if obj.length == @types.length
+        if obj.length == types.length
           item_classes = obj.map(&:class).join(', ')
           "type [#{item_classes}]"
         else

data/lib/types/types/fixed_hash.rb

@@ -5,30 +5,37 @@ module T::Types
   # Takes a hash of types. Validates each item in a hash using the type in the same position
   # in the list.
   class FixedHash < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.transform_values {|v| T::Utils.coerce(v)}
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.transform_values {|v| T::Utils.coerce(v)}
+    end
+
+    def build_type
+      types
+      nil
     end
 
     # overrides Base
     def name
-      serialize_hash(@types)
+      serialize_hash(types)
     end
 
     # overrides Base
     def recursively_valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if @types.any? {|key, type| !type.recursively_valid?(obj[key])}
-      return false if obj.any? {|key, _| !@types[key]}
+      return false if types.any? {|key, type| !type.recursively_valid?(obj[key])}
+      return false if obj.any? {|key, _| !types[key]}
       true
     end
 
     # overrides Base
     def valid?(obj)
       return false unless obj.is_a?(Hash)
-      return false if @types.any? {|key, type| !type.valid?(obj[key])}
-      return false if obj.any? {|key, _| !@types[key]}
+      return false if types.any? {|key, type| !type.valid?(obj[key])}
+      return false if obj.any? {|key, _| !types[key]}
       true
     end
 
@@ -37,7 +44,7 @@ module T::Types
       case other
       when FixedHash
         # Using `subtype_of?` here instead of == would be unsound
-        @types == other.types
+        types == other.types
       when TypedHash
         # warning: covariant hashes
 

data/lib/types/types/intersection.rb

@@ -4,10 +4,12 @@
 module T::Types
   # Takes a list of types. Validates that an object matches all of the types.
   class Intersection < Base
-    attr_reader :types
-
     def initialize(types)
-      @types = types.flat_map do |type|
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.flat_map do |type|
         type = T::Utils.resolve_alias(type)
         if type.is_a?(Intersection)
           # Simplify nested intersections (mostly so `name` returns a nicer value)
@@ -18,19 +20,24 @@ module T::Types
       end.uniq
     end
 
+    def build_type
+      types
+      nil
+    end
+
     # overrides Base
     def name
-      "T.all(#{@types.map(&:name).compact.sort.join(', ')})"
+      "T.all(#{types.map(&:name).compact.sort.join(', ')})"
     end
 
     # overrides Base
     def recursively_valid?(obj)
-      @types.all? {|type| type.recursively_valid?(obj)}
+      types.all? {|type| type.recursively_valid?(obj)}
     end
 
     # overrides Base
     def valid?(obj)
-      @types.all? {|type| type.valid?(obj)}
+      types.all? {|type| type.valid?(obj)}
     end
 
     # overrides Base

data/lib/types/types/noreturn.rb

@@ -6,6 +6,10 @@ module T::Types
   class NoReturn < Base
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.noreturn"

data/lib/types/types/proc.rb

@@ -8,21 +8,31 @@ module T::Types
   # At present, we only support fixed-arity procs with no optional or
   # keyword arguments.
   class Proc < Base
-    attr_reader :arg_types
-    attr_reader :returns
-
     def initialize(arg_types, returns)
-      @arg_types = {}
-      arg_types.each do |key, raw_type|
-        @arg_types[key] = T::Utils.coerce(raw_type)
-      end
-      @returns = T::Utils.coerce(returns)
+      @inner_arg_types = arg_types
+      @inner_returns = returns
+    end
+
+    def arg_types
+      @arg_types ||= @inner_arg_types.map do |key, raw_type|
+        [key, T::Utils.coerce(raw_type)]
+      end.to_h
+    end
+
+    def returns
+      @returns ||= T::Utils.coerce(@inner_returns)
+    end
+
+    def build_type
+      arg_types
+      returns
+      nil
     end
 
     # overrides Base
     def name
       args = []
-      @arg_types.each do |k, v|
+      arg_types.each do |k, v|
         args << "#{k}: #{v.name}"
       end
       "T.proc.params(#{args.join(', ')}).returns(#{returns})"

data/lib/types/types/self_type.rb

@@ -8,6 +8,10 @@ module T::Types
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.self_type"

data/lib/types/types/simple.rb

@@ -13,6 +13,10 @@ module T::Types
       @raw_type = raw_type
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)

data/lib/types/types/t_enum.rb

@@ -10,6 +10,10 @@ module T::Types
       @val = val
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       # Strips the #<...> off, just leaving the ...

data/lib/types/types/type_parameter.rb

@@ -20,6 +20,10 @@ module T::Types
       @name = name
     end
 
+    def build_type
+      nil
+    end
+
     def self.make(name)
       cached = Private.cached_entry(name)
       return cached if cached

data/lib/types/types/type_variable.rb

@@ -19,6 +19,10 @@ module T::Types
       @variance = variance
     end
 
+    def build_type
+      nil
+    end
+
     def valid?(obj)
       true
     end

data/lib/types/types/typed_array.rb

@@ -5,7 +5,7 @@ module T::Types
   class TypedArray < TypedEnumerable
     # overrides Base
     def name
-      "T::Array[#{@type.name}]"
+      "T::Array[#{type.name}]"
     end
 
     def underlying_class
@@ -60,6 +60,11 @@ module T::Types
         obj.is_a?(Array)
       end
 
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
       module Private
         INSTANCE = Untyped.new.freeze
       end

data/lib/types/types/typed_class.rb

@@ -3,15 +3,22 @@
 
 module T::Types
   class TypedClass < T::Types::Base
-    attr_reader :type
-
     def initialize(type)
-      @type = T::Utils.coerce(type)
+      @inner_type = type
+    end
+
+    def type
+      @type ||= T::Utils.coerce(@inner_type)
+    end
+
+    def build_type
+      type
+      nil
     end
 
     # overrides Base
     def name
-      "T::Class[#{@type.name}]"
+      "T::Class[#{type.name}]"
     end
 
     def underlying_class
@@ -67,6 +74,11 @@ module T::Types
         super(T.untyped)
       end
 
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
       module Private
         INSTANCE = Untyped.new.freeze
       end
@@ -77,6 +89,11 @@ module T::Types
         super(T.anything)
       end
 
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
       module Private
         INSTANCE = Anything.new.freeze
       end

data/lib/types/types/typed_enumerable.rb

@@ -6,10 +6,17 @@ module T::Types
   # `case` statement below in `describe_obj` in order to get better
   # error messages.
   class TypedEnumerable < Base
-    attr_reader :type
-
     def initialize(type)
-      @type = T::Utils.coerce(type)
+      @inner_type = type
+    end
+
+    def type
+      @type ||= T::Utils.coerce(@inner_type)
+    end
+
+    def build_type
+      type
+      nil
     end
 
     def underlying_class
@@ -18,7 +25,7 @@ module T::Types
 
     # overrides Base
     def name
-      "T::Enumerable[#{@type.name}]"
+      "T::Enumerable[#{type.name}]"
     end
 
     # overrides Base
@@ -34,20 +41,20 @@ module T::Types
         begin
           it = 0
           while it < obj.count
-            return false unless @type.recursively_valid?(obj[it])
+            return false unless type.recursively_valid?(obj[it])
             it += 1
           end
           true
         end
       when Hash
-        return false unless @type.is_a?(FixedArray)
-        types = @type.types
+        return false unless type.is_a?(FixedArray)
+        types = type.types
         return false if types.count != 2
         key_type = types[0]
         value_type = types[1]
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
+          # iterate over a [key, value] array, so we can't juse use the type.recursively_valid?(v)
           return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         true
@@ -65,10 +72,10 @@ module T::Types
         # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
         # of unknown types (T::Range[T.untyped]).
         # Similarly, `(nil...1)` is not a `T::Range[T.nilable(Integer)]`, it's a boundless range of Integer.
-        (obj.begin.nil? || @type.recursively_valid?(obj.begin)) && (obj.end.nil? || @type.recursively_valid?(obj.end))
+        (obj.begin.nil? || type.recursively_valid?(obj.begin)) && (obj.end.nil? || type.recursively_valid?(obj.end))
       when Set
         obj.each do |item|
-          return false unless @type.recursively_valid?(item)
+          return false unless type.recursively_valid?(item)
         end
 
         true
@@ -90,7 +97,7 @@ module T::Types
         # should be invariant because they are mutable and support
         # both reading and writing. However, Sorbet treats *all*
         # Enumerable subclasses as covariant for ease of adoption.
-        @type.subtype_of?(other.type)
+        type.subtype_of?(other.type)
       elsif other.class <= Simple
         underlying_class <= other.raw_type
       else

data/lib/types/types/typed_enumerator.rb

@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedEnumerator < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Enumerator
     end
 
     # overrides Base
     def name
-      "T::Enumerator[#{@type.name}]"
+      "T::Enumerator[#{type.name}]"
     end
 
     # overrides Base

data/lib/types/types/typed_enumerator_chain.rb

@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedEnumeratorChain < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Enumerator::Chain
     end
 
     # overrides Base
     def name
-      "T::Enumerator::Chain[#{@type.name}]"
+      "T::Enumerator::Chain[#{type.name}]"
     end
 
     # overrides Base

data/lib/types/types/typed_enumerator_lazy.rb

@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedEnumeratorLazy < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Enumerator::Lazy
     end
 
     # overrides Base
     def name
-      "T::Enumerator::Lazy[#{@type.name}]"
+      "T::Enumerator::Lazy[#{type.name}]"
     end
 
     # overrides Base

data/lib/types/types/typed_hash.rb

@@ -3,22 +3,38 @@
 
 module T::Types
   class TypedHash < TypedEnumerable
-    # Technically we don't need these, but they are a nice api
-    attr_reader :keys, :values
-
     def underlying_class
       Hash
     end
 
     def initialize(keys:, values:)
-      @keys = T::Utils.coerce(keys)
-      @values = T::Utils.coerce(values)
-      @type = T::Utils.coerce([keys, values])
+      @inner_keys = keys
+      @inner_values = values
+    end
+
+    # Technically we don't need this, but it is a nice api
+    def keys
+      @keys ||= T::Utils.coerce(@inner_keys)
+    end
+
+    # Technically we don't need this, but it is a nice api
+    def values
+      @values ||= T::Utils.coerce(@inner_values)
+    end
+
+    def type
+      @type ||= T::Utils.coerce([keys, values])
+    end
+
+    def build_type
+      keys
+      values
+      super
     end
 
     # overrides Base
     def name
-      "T::Hash[#{@keys.name}, #{@values.name}]"
+      "T::Hash[#{keys.name}, #{values.name}]"
     end
 
     # overrides Base

data/lib/types/types/typed_range.rb

@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedRange < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Hash
     end
 
     # overrides Base
     def name
-      "T::Range[#{@type.name}]"
+      "T::Range[#{type.name}]"
     end
 
     # overrides Base

data/lib/types/types/typed_set.rb

@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedSet < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Hash
     end
 
     # overrides Base
     def name
-      "T::Set[#{@type.name}]"
+      "T::Set[#{type.name}]"
     end
 
     # overrides Base

data/lib/types/types/union.rb

@@ -4,12 +4,14 @@
 module T::Types
   # Takes a list of types. Validates that an object matches at least one of the 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|
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.flat_map do |type|
         type = T::Utils.coerce(type)
         if type.is_a?(Union)
           # Simplify nested unions (mostly so `name` returns a nicer value)
@@ -20,6 +22,11 @@ module T::Types
       end.uniq
     end
 
+    def build_type
+      types
+      nil
+    end
+
     # overrides Base
     def name
       # Use the attr_reader here so we can override it in SimplePairUnion
@@ -51,12 +58,12 @@ module T::Types
 
     # overrides Base
     def recursively_valid?(obj)
-      @types.any? {|type| type.recursively_valid?(obj)}
+      types.any? {|type| type.recursively_valid?(obj)}
     end
 
     # overrides Base
     def valid?(obj)
-      @types.any? {|type| type.valid?(obj)}
+      types.any? {|type| type.valid?(obj)}
     end
 
     # overrides Base

data/lib/types/types/untyped.rb

@@ -7,6 +7,10 @@ module T::Types
 
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.untyped"

data/lib/types/utils.rb

@@ -79,8 +79,8 @@ module T::Utils
   end
 
   # Unwraps all the sigs.
-  def self.run_all_sig_blocks
-    T::Private::Methods.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
+    T::Private::Methods.run_all_sig_blocks(force_type_init: force_type_init)
   end
 
   # Return the underlying type for a type alias. Otherwise returns type.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.11170
+  version: 0.5.11175
 platform: ruby
 authors:
 - Stripe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-03 00:00:00.000000000 Z
+date: 2024-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest