sorbet-runtime 0.5.11267 → 0.5.11481

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62eef630524c0b1ad1f2a3d8749bd5f821a28ebfabbe7e4909010d530ffa698b
-  data.tar.gz: eb3fb942cb3ead21ec80e425726f823a6eb2cef834354ae2279a00c7fc5bf599
+  metadata.gz: 431470d7ca84c008524b04ee4bf8c6cf123a3f1155d3cebda13567b2cb0bb36f
+  data.tar.gz: 8054072653c10ec894ff5918d5da4b7f6e4264648b66c072bf54047d3d35ea35
 SHA512:
-  metadata.gz: 62855bc96c970aab1e89be225e336d6e7adc53b486137bb2f09457abdd9f932d23d4e6a37d05d6c8dad5d1fe098fad3b8cd4c529fcb7926e0bfefdc7b63249f3
-  data.tar.gz: d14d50ff7afbcad3fb245d2e9f815857c389b90a619fce352eca24da6be967728b748c89bac041ab71beed0f9bf4bf690c19a08b193d9ec701f0364026b7bc2b
+  metadata.gz: 9373121f07124f59fe94806df91c7dba08a97fa10446c1f5c61fad265765813db96e7cf84722ffccd31e2a02afba39fc0916e5cb8a7d265c1c8f93ad1b4a7dcb
+  data.tar.gz: e3c347a166262b7343e4105ff2aa4a10d8493adc6fa9a6ed0b5d25ae4cce1028c76df1a8166af627240e20a71f1346830936c09d990a278ddfe7a2a75c15d3e6

data/lib/sorbet-runtime.rb

@@ -117,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,68 +192,92 @@ 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 ###
 
+  UNSET = T.let(Module.new.freeze, Module)
+  private_constant :UNSET
+
   sig {params(serialized_val: SerializedVal).void}
-  def initialize(serialized_val=nil)
+  def initialize(serialized_val=UNSET)
     raise 'T::Enum is abstract' if self.class == T::Enum
     if !self.class.started_initializing?
       raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
@@ -279,7 +303,7 @@ class T::Enum
   sig {params(const_name: Symbol).void}
   def _bind_name(const_name)
     @const_name = const_name
-    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
+    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.equal?(UNSET)
     freeze
   end
 

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

@@ -4,7 +4,13 @@
 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)

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/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
-      caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `inherited'$/)}
-      T::Private::Sealed.validate_inheritance(caller_loc&.to_s, 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
 
@@ -23,14 +23,14 @@ module T::Private::Sealed
     def included(child)
       super
       caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `included'$/)}
-      T::Private::Sealed.validate_inheritance(caller_loc&.to_s, self, child, 'included')
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'included')
       @sorbet_sealed_module_all_subclasses << child
     end
 
     def extended(child)
       super
       caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `extended'$/)}
-      T::Private::Sealed.validate_inheritance(caller_loc&.to_s, self, child, '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/_props.rb

@@ -110,7 +110,7 @@ module T::Props
     #
     # @return [void]
     sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
-    def prop(name, cls, rules={})
+    def prop(name, cls, **rules)
       cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
       decorator.prop_defined(name, cls, rules)
     end
@@ -132,16 +132,16 @@ module T::Props
     end
 
     # Shorthand helper to define a `prop` with `immutable => true`
-    sig {params(name: Symbol, cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
-    def const(name, cls_or_args, args={})
+    sig {params(name: Symbol, cls_or_args: T.untyped, args: T.untyped).void}
+    def const(name, cls_or_args, **args)
       if (cls_or_args.is_a?(Hash) && cls_or_args.key?(:immutable)) || args.key?(:immutable)
         Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")
       end
 
       if cls_or_args.is_a?(Hash)
-        self.prop(name, cls_or_args.merge(immutable: true))
+        self.prop(name, **cls_or_args.merge(immutable: true))
       else
-        self.prop(name, cls_or_args, args.merge(immutable: true))
+        self.prop(name, cls_or_args, **args.merge(immutable: true))
       end
     end
 

data/lib/types/props/has_lazily_specialized_methods.rb

@@ -62,7 +62,9 @@ module T::Props
         source = lazily_defined_methods.fetch(name).call
 
         cls = decorated_class
-        cls.class_eval(source.to_s)
+        T::Configuration.without_ruby_warnings do
+          cls.class_eval(source.to_s)
+        end
         cls.send(:private, name)
       end
 

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/props/serializable.rb

@@ -261,15 +261,30 @@ module T::Props::Serializable::DecoratorMethods
   end
 
   def message_with_generated_source_context(error, generated_method, generate_source_method)
-    line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
-    return unless line_label
+    generated_method = generated_method.to_s
+    if error.backtrace_locations
+      line_loc = error.backtrace_locations.find {|l| l.base_label == generated_method}
+      return unless line_loc
 
-    line_num = if line_label.start_with?("(eval)")
-      # (eval):13:in `__t_props_generated_serialize'
-      line_label.split(':')[1]&.to_i
+      line_num = line_loc.lineno
     else
-      # (eval at /Users/jez/stripe/sorbet/gems/sorbet-runtime/lib/types/props/has_lazily_specialized_methods.rb:65):13:in `__t_props_generated_serialize'
-      line_label.split(':')[2]&.to_i
+      label = if RUBY_VERSION >= "3.4"
+        # in 'ClassName#__t_props_generated_serialize'"
+        "##{generated_method}'"
+      else
+        # in `__t_props_generated_serialize'"
+        "in `#{generated_method}'"
+      end
+      line_label = error.backtrace.find {|l| l.end_with?(label)}
+      return unless line_label
+
+      line_num = if line_label.start_with?("(eval)")
+        # (eval):13:in ...
+        line_label.split(':')[1]&.to_i
+      else
+        # (eval at /Users/jez/stripe/sorbet/gems/sorbet-runtime/lib/types/props/has_lazily_specialized_methods.rb:65):13:in ...
+        line_label.split(':')[2]&.to_i
+      end
     end
     return unless line_num
 

data/lib/types/struct.rb

@@ -39,7 +39,7 @@ class T::ImmutableStruct < T::InexactStruct
 
   # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
   sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
-  def self.prop(name, cls, rules={})
+  def self.prop(name, cls, **rules)
     return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
 
     raise "Cannot use `prop` in #{self.name} because it is an immutable struct. Use `const` instead"

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.11267
+  version: 0.5.11481
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-23 00:00:00.000000000 Z
+date: 2024-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -159,7 +159,6 @@ files:
 - 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