study_line 0.1.6 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/methods/signature_validation.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private::Methods::SignatureValidation
-  Methods = T::Private::Methods
-  Modes = Methods::Modes
-
-  def self.validate(signature)
-    # Constructors in any language are always a bit weird: they're called in a
-    # static context, but their bodies are implemented by instance methods. So
-    # a mix of the rules that apply to instance methods and class methods
-    # apply.
-    #
-    # In languages like Java and Scala, static methods/companion object methods
-    # are never inherited. (In Java it almost looks like you can inherit them,
-    # because `Child.static_parent_method` works, but this method is simply
-    # resolved statically to `Parent.static_parent_method`). Even though most
-    # instance methods overrides have variance checking done, constructors are
-    # not treated like this, because static methods are never
-    # inherited/overridden, and the constructor can only ever be called
-    # indirectly by way of the static method. (Note: this is only a mental
-    # model--there's not actually a static method for the constructor in Java,
-    # there's an `invokespecial` JVM instruction that handles this).
-    #
-    # But Ruby is not like Java: singleton class methods in Ruby *are*
-    # inherited, unlike static methods in Java. In fact, this is similar to how
-    # JavaScript works. TypeScript simply then sidesteps the issue with
-    # structural typing: `typeof Parent` is not compatible with `typeof Child`
-    # if their constructors are different. (In a nominal type system, simply
-    # having Child descend from Parent should be the only factor in determining
-    # whether those types are compatible).
-    #
-    # Flow has nominal subtyping for classes. When overriding (static and
-    # instance) methods in a child class, the overrides must satisfy variance
-    # constraints. But it still carves out an exception for constructors,
-    # because then literally every class would have to have the same
-    # constructor. This is simply unsound. Hack does a similar thing--static
-    # method overrides are checked, but not constructors. Though what Hack
-    # *does* have is a way to opt into override checking for constructors with
-    # a special annotation.
-    #
-    # It turns out, Sorbet already has this special annotation: either
-    # `abstract` or `overridable`. At time of writing, *no* static override
-    # checking happens unless marked with these keywords (though at runtime, it
-    # always happens). Getting the static system to parity with the runtime by
-    # always checking overrides would be a great place to get to one day, but
-    # for now we can take advantage of it by only doing override checks for
-    # constructors if they've opted in.
-    #
-    # (When we get around to more widely checking overrides statically, we will
-    # need to build a matching special case for constructors statically.)
-    #
-    # Note that this breaks with tradition: normally, constructors are not
-    # allowed to be abstract. But that's kind of a side-effect of everything
-    # above: in Java/Scala, singleton class methods are never abstract because
-    # they're not inherited, and this extends to constructors. TypeScript
-    # simply rejects `new klass()` entirely if `klass` is
-    # `typeof AbstractClass`, requiring instead that you write
-    # `{ new(): AbstractClass }`. We may want to consider building some
-    # analogue to `T.class_of` in the future that works like this `{new():
-    # ...}` type.
-    if signature.method_name == :initialize && signature.method.owner.is_a?(Class)
-      if signature.mode == Modes.standard
-        return
-      end
-    end
-
-    super_method = signature.method.super_method
-
-    if super_method && super_method.owner != signature.method.owner
-      Methods.maybe_run_sig_block_for_method(super_method)
-      super_signature = Methods.signature_for_method(super_method)
-
-      # If the super_method has any kwargs we can't build a
-      # Signature for it, so we'll just skip validation in that case.
-      if !super_signature && !super_method.parameters.select {|kind, _| kind == :rest || kind == :kwrest}.empty?
-        nil
-      else
-        # super_signature can be nil when we're overriding a method (perhaps a builtin) that didn't use
-        # one of the method signature helpers. Use an untyped signature so we can still validate
-        # everything but types.
-        #
-        # We treat these signatures as overridable, that way people can use `.override` with
-        # overrides of builtins. In the future we could try to distinguish when the method is a
-        # builtin and treat non-builtins as non-overridable (so you'd be forced to declare them with
-        # `.overridable`).
-        #
-        super_signature ||= Methods::Signature.new_untyped(method: super_method)
-
-        validate_override_mode(signature, super_signature)
-        validate_override_shape(signature, super_signature)
-        validate_override_types(signature, super_signature)
-      end
-    else
-      validate_non_override_mode(signature)
-    end
-  end
-
-  private_class_method def self.pretty_mode(signature)
-    if signature.mode == Modes.overridable_override
-      '.overridable.override'
-    else
-      ".#{signature.mode}"
-    end
-  end
-
-  def self.validate_override_mode(signature, super_signature)
-    case signature.mode
-    when *Modes::OVERRIDE_MODES
-      # Peaceful
-    when Modes.abstract
-      # Either the parent method is abstract, or it's not.
-      #
-      # If it's abstract, we want to allow overriding abstract with abstract to
-      # possibly narrow the type or provide more specific documentation.
-      #
-      # If it's not, then marking this method `abstract` will silently be a no-op.
-      # That's bad and we probably want to report an error, but fixing that
-      # will have to be a separate fix (that bad behavior predates this current
-      # comment, introduced when we fixed the abstract/abstract case).
-      #
-      # Therefore:
-      # Peaceful (mostly)
-    when *Modes::NON_OVERRIDE_MODES
-      if super_signature.mode == Modes.standard
-        # Peaceful
-      elsif super_signature.mode == Modes.abstract
-        raise "You must use `.override` when overriding the abstract method `#{signature.method_name}`.\n" \
-              "  Abstract definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Implementation definition: #{method_loc_str(signature.method)}\n"
-      elsif super_signature.mode != Modes.untyped
-        raise "You must use `.override` when overriding the existing method `#{signature.method_name}`.\n" \
-              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Child definition:  #{method_loc_str(signature.method)}\n"
-      end
-    else
-      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-  end
-
-  def self.validate_non_override_mode(signature)
-    case signature.mode
-    when Modes.override
-      if signature.method_name == :each && signature.method.owner < Enumerable
-        # Enumerable#each is the only method in Sorbet's RBI payload that defines an abstract method.
-        # Enumerable#each does not actually exist at runtime, but it is required to be implemented by
-        # any class which includes Enumerable. We want to declare Enumerable#each as abstract so that
-        # people can call it anything which implements the Enumerable interface, and so that it's a
-        # static error to forget to implement it.
-        #
-        # This is a one-off hack, and we should think carefully before adding more methods here.
-        nil
-      else
-        raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overriden.\n" \
-          "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
-          "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
-      end
-    when Modes.standard, *Modes::NON_OVERRIDE_MODES
-      # Peaceful
-      nil
-    else
-      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    # Given a singleton class, we can check if it belongs to a
-    # module by looking at its superclass; given `module M`,
-    # `M.singleton_class.superclass == Module`, which is not true
-    # for any class.
-    owner = signature.method.owner
-    if (signature.mode == Modes.abstract || Modes::OVERRIDABLE_MODES.include?(signature.mode)) &&
-        owner.singleton_class? && owner.superclass == Module
-      raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
-            "on a module is not allowed. Class methods on " \
-            "modules do not get inherited and thus cannot be overridden."
-    end
-  end
-
-  def self.validate_override_shape(signature, super_signature)
-    return if signature.override_allow_incompatible
-    return if super_signature.mode == Modes.untyped
-
-    method_name = signature.method_name
-    mode_verb = super_signature.mode == Modes.abstract ? 'implements' : 'overrides'
-
-    if !signature.has_rest && signature.arg_count < super_signature.arg_count
-      raise "Your definition of `#{method_name}` must accept at least #{super_signature.arg_count} " \
-            "positional arguments to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if !signature.has_rest && super_signature.has_rest
-      raise "Your definition of `#{method_name}` must have `*#{super_signature.rest_name}` " \
-            "to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if signature.req_arg_count > super_signature.req_arg_count
-      raise "Your definition of `#{method_name}` must have no more than #{super_signature.req_arg_count} " \
-            "required argument(s) to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if !signature.has_keyrest
-      # O(nm), but n and m are tiny here
-      missing_kwargs = super_signature.kwarg_names - signature.kwarg_names
-      if !missing_kwargs.empty?
-        raise "Your definition of `#{method_name}` is missing these keyword arg(s): #{missing_kwargs} " \
-              "which are defined in the method it #{mode_verb}: " \
-              "#{base_override_loc_str(signature, super_signature)}"
-      end
-    end
-
-    if !signature.has_keyrest && super_signature.has_keyrest
-      raise "Your definition of `#{method_name}` must have `**#{super_signature.keyrest_name}` " \
-            "to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    # O(nm), but n and m are tiny here
-    extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
-    if !extra_req_kwargs.empty?
-      raise "Your definition of `#{method_name}` has extra required keyword arg(s) " \
-            "#{extra_req_kwargs} relative to the method it #{mode_verb}, making it incompatible: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if super_signature.block_name && !signature.block_name
-      raise "Your definition of `#{method_name}` must accept a block parameter to be compatible " \
-            "with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-  end
-
-  def self.validate_override_types(signature, super_signature)
-    return if signature.override_allow_incompatible
-    return if super_signature.mode == Modes.untyped
-    return unless [signature, super_signature].all? do |sig|
-      sig.check_level == :always || sig.check_level == :compiled || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-    end
-    mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
-
-    # arg types must be contravariant
-    super_signature.arg_types.zip(signature.arg_types).each_with_index do |((_super_name, super_type), (name, type)), index|
-      if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg ##{index + 1} (`#{name}`) in signature for #{mode_noun} of method " \
-              "`#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
-              "(The types must be contravariant.)"
-      end
-    end
-
-    # kwarg types must be contravariant
-    super_signature.kwarg_types.each do |name, super_type|
-      type = signature.kwarg_types[name]
-      if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg `#{name}` in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
-              "(The types must be contravariant.)"
-      end
-    end
-
-    # return types must be covariant
-    if !signature.return_type.subtype_of?(super_signature.return_type)
-      raise "Incompatible return type in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-            "* Base: `#{super_signature.return_type}` (in #{method_loc_str(super_signature.method)})\n" \
-            "* #{mode_noun.capitalize}: `#{signature.return_type}` (in #{method_loc_str(signature.method)})\n" \
-            "(The types must be covariant.)"
-    end
-  end
-
-  private_class_method def self.base_override_loc_str(signature, super_signature)
-    mode_noun = super_signature.mode == Modes.abstract ? 'Implementation' : 'Override'
-    "\n * Base definition: in #{method_loc_str(super_signature.method)}" \
-    "\n * #{mode_noun}: in #{method_loc_str(signature.method)}"
-  end
-
-  private_class_method def self.method_loc_str(method)
-    loc = if method.source_location
-      method.source_location.join(':')
-    else
-      "<unknown location>"
-    end
-    "#{method.owner} at #{loc}"
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/mixins/mixins.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private
-  module MixesInClassMethods
-    def included(other)
-      mods = Abstract::Data.get(self, :class_methods_mixins)
-      mods.each {|mod| other.extend(mod)}
-      super
-    end
-  end
-
-  module Mixins
-    def self.declare_mixes_in_class_methods(mixin, class_methods)
-      if mixin.is_a?(Class)
-        raise "Classes cannot be used as mixins, and so mixes_in_class_methods cannot be used on a Class."
-      end
-
-      if Abstract::Data.key?(mixin, :class_methods_mixins)
-        class_methods = Abstract::Data.get(mixin, :class_methods_mixins) + class_methods
-      end
-
-      mixin.singleton_class.include(MixesInClassMethods)
-      Abstract::Data.set(mixin, :class_methods_mixins, class_methods)
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/retry.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private::Retry
-
-  # A special singleton used for static analysis of exceptions.
-  module RETRY
-    freeze
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/runtime_levels.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# Used in `sig.checked(level)` to determine when runtime type checking
-# is enabled on a method.
-module T::Private::RuntimeLevels
-  LEVELS = [
-    # Validate every call in every environment
-    :always,
-    # Validate in tests, but not in production
-    :tests,
-    # Don't even validate in tests, b/c too expensive,
-    # or b/c we fully trust the static typing
-    :never,
-    # Validate the sig when the file is using the Sorbet Compiler.
-    # Behaves like :never when interpreted.
-    :compiled,
-  ].freeze
-
-  @check_tests = false
-  @wrapped_tests_with_validation = false
-
-  @has_read_default_checked_level = false
-  @default_checked_level = :always
-
-  def self.check_tests?
-    # Assume that this code path means that some `sig.checked(:tests)`
-    # has been wrapped (or not wrapped) already, which is a trapdoor
-    # for toggling `@check_tests`.
-    @wrapped_tests_with_validation = true
-
-    @check_tests
-  end
-
-  def self.enable_checking_in_tests
-    if !@check_tests && @wrapped_tests_with_validation
-      all_checked_tests_sigs = T::Private::Methods.all_checked_tests_sigs
-      locations = all_checked_tests_sigs.map {|sig| sig.method.source_location.join(':')}.join("\n- ")
-      raise "Toggle `:tests`-level runtime type checking earlier. " \
-        "There are already some methods wrapped with `sig.checked(:tests)`:\n" \
-        "- #{locations}"
-    end
-
-    _toggle_checking_tests(true)
-  end
-
-  def self.default_checked_level
-    @has_read_default_checked_level = true
-    @default_checked_level
-  end
-
-  def self.default_checked_level=(default_checked_level)
-    if @has_read_default_checked_level
-      raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
-    end
-    if !LEVELS.include?(default_checked_level)
-      raise "Invalid `checked` level '#{default_checked_level}'. Use one of: #{LEVELS}."
-    end
-
-    @default_checked_level = default_checked_level
-  end
-
-  def self._toggle_checking_tests(checked)
-    @check_tests = checked
-  end
-
-  private_class_method def self.set_enable_checking_in_tests_from_environment
-    if ENV['SORBET_RUNTIME_ENABLE_CHECKING_IN_TESTS']
-      enable_checking_in_tests
-    end
-  end
-  set_enable_checking_in_tests_from_environment
-
-  private_class_method def self.set_default_checked_level_from_environment
-    level = ENV['SORBET_RUNTIME_DEFAULT_CHECKED_LEVEL']
-    if level
-      self.default_checked_level = level.to_sym
-    end
-  end
-  set_default_checked_level_from_environment
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/sealed.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-module T::Private::Sealed
-  module NoInherit
-    def inherited(child)
-      super
-      this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'inherited')
-      @sorbet_sealed_module_all_subclasses << child
-    end
-
-    def sealed_subclasses
-      @sorbet_sealed_module_all_subclasses_set ||= # rubocop:disable Naming/MemoizedInstanceVariableName
-        begin
-          require 'set'
-          Set.new(@sorbet_sealed_module_all_subclasses).freeze
-        end
-    end
-  end
-
-  module NoIncludeExtend
-    def included(child)
-      super
-      this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'included')
-      @sorbet_sealed_module_all_subclasses << child
-    end
-
-    def extended(child)
-      super
-      this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'extended')
-      @sorbet_sealed_module_all_subclasses << child
-    end
-
-    def sealed_subclasses
-      # this will freeze the set so that you can never get into a
-      # state where you use the subclasses list and then something
-      # else will add to it
-      @sorbet_sealed_module_all_subclasses_set ||= # rubocop:disable Naming/MemoizedInstanceVariableName
-        begin
-          require 'set'
-          Set.new(@sorbet_sealed_module_all_subclasses).freeze
-        end
-    end
-  end
-
-  def self.declare(mod, decl_file)
-    if !mod.is_a?(Module)
-      raise "#{mod} is not a class or module and cannot be declared `sealed!`"
-    end
-    if sealed_module?(mod)
-      raise "#{mod} was already declared `sealed!` and cannot be re-declared `sealed!`"
-    end
-    if T::Private::Final.final_module?(mod)
-      raise "#{mod} was already declared `final!` and cannot be declared `sealed!`"
-    end
-    mod.extend(mod.is_a?(Class) ? NoInherit : NoIncludeExtend)
-    if !decl_file
-      raise "Couldn't determine declaration file for sealed class."
-    end
-    mod.instance_variable_set(:@sorbet_sealed_module_decl_file, decl_file)
-    mod.instance_variable_set(:@sorbet_sealed_module_all_subclasses, [])
-  end
-
-  def self.sealed_module?(mod)
-    mod.instance_variable_defined?(:@sorbet_sealed_module_decl_file)
-  end
-
-  def self.validate_inheritance(this_line, parent, child, verb)
-    this_file = this_line&.split(':')&.first
-    decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file) if sealed_module?(parent)
-
-    if !this_file
-      raise "Could not use backtrace to determine file for #{verb} child #{child}"
-    end
-    if !decl_file
-      raise "#{parent} does not seem to be a sealed module (#{verb} by #{child})"
-    end
-
-    if !this_file.start_with?(decl_file)
-      whitelist = T::Configuration.sealed_violation_whitelist
-      if !whitelist.nil? && whitelist.any? {|pattern| this_file =~ pattern}
-        return
-      end
-
-      raise "#{parent} was declared sealed and can only be #{verb} in #{decl_file}, not #{this_file}"
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/types/not_typed.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# A placeholder for when an untyped thing must provide a type.
-# Raises an exception if it is ever used for validation.
-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"
-
-  # overrides Base
-  def name
-    "<NOT-TYPED>"
-  end
-
-  # overrides Base
-  def valid?(obj)
-    raise ERROR_MESSAGE
-  end
-
-  # overrides Base
-  private def subtype_of_single?(other)
-    raise ERROR_MESSAGE
-  end
-
-  INSTANCE = ::T::Private::Types::NotTyped.new.freeze
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/types/simple_pair_union.rb

@@ -1,55 +0,0 @@
-# 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
-
-  # overrides Union
-  def unwrap_nilable
-    a_nil = @raw_a.equal?(NilClass)
-    b_nil = @raw_b.equal?(NilClass)
-    if a_nil
-      return types[1]
-    end
-    if b_nil
-      return types[0]
-    end
-    nil
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/types/string_holder.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# Holds a string. Useful for showing type aliases in error messages
-class T::Private::Types::StringHolder < T::Types::Base
-  attr_reader :string
-
-  def initialize(string)
-    @string = string
-  end
-
-  # overrides Base
-  def name
-    string
-  end
-
-  # overrides Base
-  def valid?(obj)
-    false
-  end
-
-  # overrides Base
-  private def subtype_of_single?(other)
-    false
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/types/type_alias.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private::Types
-  # Wraps a proc for a type alias to defer its evaluation.
-  class TypeAlias < T::Types::Base
-
-    def initialize(callable)
-      @callable = callable
-    end
-
-    def aliased_type
-      @aliased_type ||= T::Utils.coerce(@callable.call)
-    end
-
-    # overrides Base
-    def name
-      aliased_type.name
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      aliased_type.recursively_valid?(obj)
-    end
-
-    # overrides Base
-    def valid?(obj)
-      aliased_type.valid?(obj)
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/sorbet-runtime-0.5.11108/lib/types/private/types/void.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# A marking class for when methods return void.
-# Should never appear in types directly.
-module T::Private::Types
-  class Void < T::Types::Base
-    ERROR_MESSAGE = "Validation is being done on an `Void`. Please report this bug at https://github.com/sorbet/sorbet/issues"
-
-    # The actual return value of `.void` methods.
-    #
-    # Uses `module VOID` because this gives it a readable name when someone
-    # examines it in Pry or with `#inspect` like:
-    #
-    #     T::Private::Types::Void::VOID
-    #
-    module VOID
-      freeze
-    end
-
-    # overrides Base
-    def name
-      "<VOID>"
-    end
-
-    # overrides Base
-    def valid?(obj)
-      raise ERROR_MESSAGE
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      raise ERROR_MESSAGE
-    end
-
-    module Private
-      INSTANCE = Void.new.freeze
-    end
-  end
-end