sorbet-runtime 0.5.11258 → 0.5.11422

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bce12129d6264f3e6cbfbe582a5e7a3e2ee6d852a9002dc78ca173dd1712f5b
-  data.tar.gz: 6baca29859ae322cc2c8ae26260781790c3fe092c4a3f8b5e593b3085d23ce3d
+  metadata.gz: a675bfbf51b32916be960aadcc1411329f21729d5ceb2218509da82d20387ddd
+  data.tar.gz: a39ec7df0cf067c2c31d22f557caea810c37c4985c1437a28e03b5db72036c0b
 SHA512:
-  metadata.gz: 264379318720331ccb920ff4b7c21d4396473a96e8ad81b7daf52121d40dcd09819853e1d6c35a49c8d2e16a3a50c87b8b443be71f1d709a7709def8dc6780c2
-  data.tar.gz: e82f3616393a7c7fe4533b67e00b3f8757dd850b53e3b37963aa7f290b13febda9b6c07e9f478c35da05f2a22567ef7e3c873c226953aedaca39f96b380cf60a
+  metadata.gz: dab2fb9c543e4eb0c652446435ad9c7a41d3850a3a2eefda6fc25a64181cbbe8a027e7313f37eea42c1bc14771be5bd6ff2799b4589668d43c4d1a3f91840953
+  data.tar.gz: '09c74373b54c24f90a63106bc726ab4fb66d61dca523bb4323effc9072bf08162135b52deb3ad648b31be156ccd609f907efc30015a5bac3b14f83f5d53bf384'

data/lib/sorbet-runtime.rb

@@ -19,6 +19,7 @@ module T::Private::Types; end
 require_relative 'types/configuration'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
+require_relative 'types/private/caller_utils'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
@@ -116,6 +117,3 @@ require_relative 'types/struct'
 require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'
-
-# Sorbet Compiler support module
-require_relative 'types/private/compiler'

data/lib/types/configuration.rb

@@ -113,7 +113,7 @@ module T::Configuration
   # statically, so that methods don't have to guard themselves from being
   # called incorrectly by untyped code.
   #
-  # @param [:never, :compiled, :tests, :always] default_checked_level
+  # @param [:never, :tests, :always] default_checked_level
   def self.default_checked_level=(default_checked_level)
     T::Private::RuntimeLevels.default_checked_level = default_checked_level
   end
@@ -536,6 +536,7 @@ module T::Configuration
 
   @legacy_t_enum_migration_mode = false
   def self.enable_legacy_t_enum_migration_mode
+    T::Enum.include(T::Enum::LegacyMigrationMode)
     @legacy_t_enum_migration_mode = true
   end
   def self.disable_legacy_t_enum_migration_mode

data/lib/types/enum.rb

@@ -192,62 +192,83 @@ class T::Enum
   # responds to the `to_str` method. It does not actually call `to_str` however.
   #
   # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
-  sig {returns(String)}
+  T::Sig::WithoutRuntime.sig {returns(String)}
   def to_str
     msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
     if T::Configuration.legacy_t_enum_migration_mode?
       T::Configuration.soft_assert_handler(
         msg,
-        storytime: {class: self.class.name},
+        storytime: {
+          class: self.class.name,
+          caller_location: Kernel.caller_locations(1..1)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+        },
       )
       serialize.to_s
     else
-      raise NoMethodError.new(msg)
+      Kernel.raise NoMethodError.new(msg)
     end
   end
 
-  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
-  def ==(other)
-    case other
-    when String
-      if T::Configuration.legacy_t_enum_migration_mode?
-        comparison_assertion_failed(:==, other)
-        self.serialize == other
+  module LegacyMigrationMode
+    include Kernel
+    extend T::Helpers
+    abstract!
+
+    if T.unsafe(false)
+      # Declare to the type system that the `serialize` method for sure exists
+      # on whatever we mix this into.
+      T::Sig::WithoutRuntime.sig {abstract.returns(T.untyped)}
+      def serialize; end
+    end
+
+    # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
+    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    def ==(other)
+      case other
+      when String
+        if T::Configuration.legacy_t_enum_migration_mode?
+          comparison_assertion_failed(:==, other)
+          self.serialize == other
+        else
+          false
+        end
       else
-        false
+        super(other)
       end
-    else
-      super(other)
     end
-  end
 
-  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
-  def ===(other)
-    case other
-    when String
-      if T::Configuration.legacy_t_enum_migration_mode?
-        comparison_assertion_failed(:===, other)
-        self.serialize == other
+    # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
+    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    def ===(other)
+      case other
+      when String
+        if T::Configuration.legacy_t_enum_migration_mode?
+          comparison_assertion_failed(:===, other)
+          self.serialize == other
+        else
+          false
+        end
       else
-        false
+        super(other)
       end
-    else
-      super(other)
     end
-  end
 
-  sig {params(method: Symbol, other: T.untyped).void}
-  private def comparison_assertion_failed(method, other)
-    T::Configuration.soft_assert_handler(
-      'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
-      storytime: {
-        class: self.class.name,
-        self: self.inspect,
-        other: other,
-        other_class: other.class.name,
-        method: method,
-      }
-    )
+    # WithoutRuntime so that caller_locations can assume a constant stack depth
+    # (Otherwise, the first call would be the method with the wrapping, which would have a different stack depth.)
+    T::Sig::WithoutRuntime.sig {params(method: Symbol, other: T.untyped).void}
+    private def comparison_assertion_failed(method, other)
+      T::Configuration.soft_assert_handler(
+        'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
+        storytime: {
+          class: self.class.name,
+          self: self.inspect,
+          other: other,
+          other_class: other.class.name,
+          method: method,
+          caller_location: Kernel.caller_locations(2..2)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+        }
+      )
+    end
   end
 
   ### Private implementation ###

data/lib/types/non_forcing_constants.rb

@@ -4,20 +4,13 @@
 module T::NonForcingConstants
   # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
   # shows up in the hover/completion documentation via LSP.
-  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
-  def self.non_forcing_is_a?(val, klass, package: nil)
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass)
     method_name = "T::NonForcingConstants.non_forcing_is_a?"
     if klass.empty?
       raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
     end
 
-    # We don't treat packages differently at runtime, but the static
-    # type-checker still needs to have the package and constant
-    # separated out. This just re-assembles the string as needed
-    if !package.nil?
-      klass = "::#{package}::#{klass}"
-    end
-
     current_klass = T.let(nil, T.nilable(Module))
     current_prefix = T.let(nil, T.nilable(String))
 
@@ -25,10 +18,7 @@ module T::NonForcingConstants
     parts.each do |part|
       if current_klass.nil?
         # First iteration
-        if part != "" && package.nil?
-          # if we've supplied a package, we're probably running in
-          # package mode, which means absolute references are
-          # meaningless
+        if part != ""
           raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
         end
 
@@ -37,7 +27,7 @@ module T::NonForcingConstants
 
         # if this had a :: prefix, then there's no more loading to
         # do---skip to the next one
-        next if part == ""
+        next
       end
 
       if current_klass.autoload?(part)

data/lib/types/private/caller_utils.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::CallerUtils
+  if Thread.respond_to?(:each_caller_location) # RUBY_VERSION >= "3.2"
+    def self.find_caller
+      skipped_first = false
+      Thread.each_caller_location do |loc|
+        unless skipped_first
+          skipped_first = true
+          next
+        end
+
+        next if loc.path&.start_with?("<internal:")
+
+        return loc if yield(loc)
+      end
+      nil
+    end
+  else
+    def self.find_caller
+      caller_locations(2).find do |loc|
+        !loc.path&.start_with?("<internal:") && yield(loc)
+      end
+    end
+  end
+end

data/lib/types/private/class_utils.rb

@@ -65,7 +65,7 @@ module T::Private::ClassUtils
     elsif mod.private_method_defined?(name)
       :private
     else
-      raise NameError.new("undefined method `#{name}` for `#{mod}`")
+      mod.method(name) # Raises
     end
   end
 

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

@@ -168,7 +168,7 @@ module T::Private::Methods
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations.find {|l| !l.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
+        caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.path.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"

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

@@ -291,11 +291,21 @@ module T::Private::Methods::CallValidation
 
   def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
     caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
-    definition_file, definition_line = method_sig.method.source_location
+    method = method_sig.method
+    definition_file, definition_line = method.source_location
+
+    owner = method.owner
+    pretty_method_name =
+      if owner.singleton_class? && owner.respond_to?(:attached_object)
+        # attached_object is new in Ruby 3.2
+        "#{owner.attached_object}.#{method.name}"
+      else
+        "#{owner}##{method.name}"
+      end
 
     pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \
       "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
-      "Definition: #{definition_file}:#{definition_line}"
+      "Definition: #{definition_file}:#{definition_line} (#{pretty_method_name})"
 
     T::Configuration.call_validation_error_handler(
       method_sig,
@@ -318,7 +328,7 @@ module T::Private::Methods::CallValidation
     elsif mod.private_method_defined?(name)
       :private
     else
-      raise NameError.new("undefined method `#{name}` for `#{mod}`")
+      mod.method(name) # Raises
     end
   end
 end

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

@@ -101,7 +101,7 @@ module T::Private::Methods
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      if (level == :never || level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+      if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked(:#{level}) with .on_failure because .on_failure will have no effect.")
       end
       if !T::Private::RuntimeLevels::LEVELS.include?(level)
@@ -119,7 +119,7 @@ module T::Private::Methods
       if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
       end
-      if decl.checked == :never || decl.checked == :compiled
+      if decl.checked == :never
         raise BuilderError.new("You can't use .on_failure with .checked(:#{decl.checked}) because .on_failure will have no effect.")
       end
 
@@ -222,7 +222,7 @@ module T::Private::Methods
       end
       if decl.checked.equal?(ARG_NOT_PROVIDED)
         default_checked_level = T::Private::RuntimeLevels.default_checked_level
-        if (default_checked_level == :never || default_checked_level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
           raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
         end
         decl.checked = default_checked_level

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

@@ -234,7 +234,7 @@ module T::Private::Methods::SignatureValidation
     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?)
+      sig.check_level == :always || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
     end
     mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
 

data/lib/types/private/runtime_levels.rb

@@ -12,9 +12,6 @@ module T::Private::RuntimeLevels
     # 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

data/lib/types/private/sealed.rb

@@ -5,8 +5,8 @@ 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')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| loc.base_label != 'inherited'}
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'inherited')
       @sorbet_sealed_module_all_subclasses << child
     end
 
@@ -22,15 +22,15 @@ module T::Private::Sealed
   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')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `included'$/)}
+      T::Private::Sealed.validate_inheritance(caller_loc, 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')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `extended'$/)}
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'extended')
       @sorbet_sealed_module_all_subclasses << child
     end
 
@@ -68,8 +68,8 @@ module T::Private::Sealed
     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
+  def self.validate_inheritance(caller_loc, parent, child, verb)
+    this_file = caller_loc&.path
     decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file) if sealed_module?(parent)
 
     if !this_file

data/lib/types/props/pretty_printable.rb

@@ -7,13 +7,13 @@ module T::Props::PrettyPrintable
 
   # 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
+    klass = 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.group(1, "<#{klass.inspect_class_with_decoration(self)}", ">") do
+      klass.all_props.sort.each do |prop|
         pp.breakable
-        val = clazz.get(self, prop)
-        rules = clazz.prop_rules(prop)
+        val = klass.get(self, prop)
+        rules = klass.prop_rules(prop)
         pp.text("#{prop}=")
         if (custom_inspect = rules[:inspect])
           inspected = if T::Utils.arity(custom_inspect) == 1
@@ -28,7 +28,7 @@ module T::Props::PrettyPrintable
           val.pretty_print(pp)
         end
       end
-      clazz.pretty_print_extra(self, pp)
+      klass.pretty_print_extra(self, pp)
     end
   end
 

data/lib/types/types/enum.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.11258
+  version: 0.5.11422
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-15 00:00:00.000000000 Z
+date: 2024-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -156,9 +156,9 @@ files:
 - 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
 - lib/types/private/decl_state.rb
 - lib/types/private/final.rb
 - lib/types/private/methods/_methods.rb

data/lib/types/private/compiler.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private
-  module Compiler
-    # If this code ever runs, the caller is running interpreted (or the
-    # compiler didn't see the call to `running_compiled?` statically.)
-    #
-    # The Sorbet Compiler replaces calls to this method unconditionally (no
-    # runtime guards) to return `true` when compiling a file.
-    def self.running_compiled?
-      false
-    end
-
-    # Returns `nil` because the compiler isn't running.
-    #
-    # The Sorbet Compiler replaces calls to this method unconditionally (no
-    # runtime guards) to return a String showing the Sorbet Compiler's version
-    # string.
-    def self.compiler_version
-      nil
-    end
-  end
-end