sorbet-runtime 0.5.11144 → 0.5.11264

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 just 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
@@ -165,7 +172,7 @@ module T::Types
         if T::Configuration::AT_LEAST_RUBY_2_7
           Object.instance_method(:class).bind_call(obj)
         else
-          Object.instance_method(:class).bind(obj).call
+          Object.instance_method(:class).bind(obj).call # rubocop:disable Performance/BindCall
         end
       end
     end

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,32 @@
 
 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
 
     # 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

@@ -4,6 +4,7 @@
 module T::Utils
   module Private
     def self.coerce_and_check_module_types(val, check_val, check_module_type)
+      # rubocop:disable Style/CaseLikeIf
       if val.is_a?(T::Types::Base)
         if val.is_a?(T::Private::Types::TypeAlias)
           val.aliased_type
@@ -31,6 +32,7 @@ module T::Utils
         raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
               "class/module, or an array. Got a `#{val.class}`."
       end
+      # rubocop:enable Style/CaseLikeIf
     end
   end
 
@@ -79,8 +81,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.
@@ -173,7 +175,7 @@ module T::Utils
     def self.get_type_info(prop_type)
       if prop_type.is_a?(T::Types::Union)
         non_nilable_type = prop_type.unwrap_nilable
-        if non_nilable_type&.is_a?(T::Types::Simple)
+        if non_nilable_type.is_a?(T::Types::Simple)
           non_nilable_type = non_nilable_type.raw_type
         end
         TypeInfo.new(true, non_nilable_type)
@@ -188,7 +190,7 @@ module T::Utils
     def self.get_underlying_type(prop_type)
       if prop_type.is_a?(T::Types::Union)
         non_nilable_type = prop_type.unwrap_nilable
-        if non_nilable_type&.is_a?(T::Types::Simple)
+        if non_nilable_type.is_a?(T::Types::Simple)
           non_nilable_type = non_nilable_type.raw_type
         end
         non_nilable_type || prop_type

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.11144
+  version: 0.5.11264
 platform: ruby
 authors:
 - Stripe
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-01 00:00:00.000000000 Z
+date: 2024-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -56,30 +56,30 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.57.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.57.1
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.13.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.13.2
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +122,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.7.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.7.1
 - !ruby/object:Gem::Dependency
   name: subprocess
   requirement: !ruby/object:Gem::Requirement
@@ -151,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.5.3
 description: Sorbet's runtime type checking component
-email:
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -165,12 +151,12 @@ files:
 - lib/types/enum.rb
 - lib/types/generic.rb
 - lib/types/helpers.rb
-- lib/types/interface_wrapper.rb
 - lib/types/non_forcing_constants.rb
 - lib/types/private/abstract/data.rb
 - lib/types/private/abstract/declare.rb
 - lib/types/private/abstract/hooks.rb
 - lib/types/private/abstract/validate.rb
+- lib/types/private/caller_utils.rb
 - lib/types/private/casts.rb
 - lib/types/private/class_utils.rb
 - lib/types/private/compiler.rb
@@ -249,7 +235,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
@@ -264,8 +250,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.5.3
+signing_key: 
 specification_version: 4
 summary: Sorbet runtime
 test_files: []

data/lib/types/interface_wrapper.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# Wraps an object, exposing only the methods defined on a given class/module. The idea is that, in
-# the absence of a static type checker that would prevent you from calling non-Bar methods on a
-# variable of type Bar, we can use these wrappers as a way of enforcing it at runtime.
-#
-# Once we ship static type checking, we should get rid of this entirely.
-class T::InterfaceWrapper
-  extend T::Sig
-
-  module Helpers
-    def wrap_instance(obj)
-      T::InterfaceWrapper.wrap_instance(obj, self)
-    end
-
-    def wrap_instances(arr)
-      T::InterfaceWrapper.wrap_instances(arr, self)
-    end
-  end
-
-  private_class_method :new # use `wrap_instance`
-
-  def self.wrap_instance(obj, interface_mod)
-    wrapper = wrapped_dynamic_cast(obj, interface_mod)
-    if wrapper.nil?
-      raise "#{obj.class} cannot be cast to #{interface_mod}"
-    end
-    wrapper
-  end
-
-  sig do
-    params(
-      arr: Array,
-      interface_mod: T.untyped
-    )
-    .returns(Array)
-  end
-  def self.wrap_instances(arr, interface_mod)
-    arr.map {|instance| self.wrap_instance(instance, interface_mod)}
-  end
-
-  def initialize(target_obj, interface_mod)
-    if target_obj.is_a?(T::InterfaceWrapper)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: wrapping a wrapper. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if !target_obj.is_a?(interface_mod)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: `is_a?` failed. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if target_obj.class == interface_mod
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: exact class match. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    @target_obj = target_obj
-    @interface_mod = interface_mod
-    self_methods = self.class.self_methods
-
-    # If perf becomes an issue, we can define these on an anonymous subclass, and keep a cache
-    # so we only need to do it once per unique `interface_mod`
-    T::Utils.methods_excluding_object(interface_mod).each do |method_name|
-      if self_methods.include?(method_name)
-        raise "interface_mod has a method that conflicts with #{self.class}: #{method_name}"
-      end
-
-      define_singleton_method(method_name) do |*args, &blk|
-        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)
-        singleton_class.send(:protected, method_name)
-      elsif target_obj.singleton_class.private_method_defined?(method_name)
-        singleton_class.send(:private, method_name)
-      else
-        raise "This should never happen. Report this bug at https://github.com/sorbet/sorbet/issues"
-      end
-    end
-  end
-
-  def kind_of?(other)
-    is_a?(other)
-  end
-
-  def is_a?(other)
-    if !other.is_a?(Module)
-      raise TypeError.new("class or module required")
-    end
-
-    # This makes is_a? return true for T::InterfaceWrapper (and its ancestors),
-    # as well as for @interface_mod and its ancestors.
-    self.class <= other || @interface_mod <= other
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @target_obj
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @interface_mod
-  end
-
-  # "Cast" an object to another type. If `obj` is an InterfaceWrapper, returns the the wrapped
-  # object if that matches `type`. Otherwise, returns `obj` if it matches `type`. Otherwise,
-  # returns nil.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  #
-  # @example
-  #   if (impl = T::InterfaceWrapper.dynamic_cast(iface, MyImplementation))
-  #     impl.do_things
-  #   end
-  def self.dynamic_cast(obj, mod)
-    if obj.is_a?(T::InterfaceWrapper)
-      target_obj = obj.__target_obj_DO_NOT_USE
-      target_obj.is_a?(mod) ? target_obj : nil
-    elsif obj.is_a?(mod)
-      obj
-    else
-      nil
-    end
-  end
-
-  # Like dynamic_cast, but puts the result in its own wrapper if necessary.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  def self.wrapped_dynamic_cast(obj, mod)
-    # Avoid unwrapping and creating an equivalent wrapper.
-    if obj.is_a?(T::InterfaceWrapper) && obj.__interface_mod_DO_NOT_USE == mod
-      return obj
-    end
-
-    cast_obj = dynamic_cast(obj, mod)
-    if cast_obj.nil?
-      nil
-    elsif cast_obj.class == mod
-      # Nothing to wrap, they want the full class
-      cast_obj
-    else
-      new(cast_obj, mod)
-    end
-  end
-
-  def self.self_methods
-    @self_methods ||= self.instance_methods(false).to_set
-  end
-end