sorbet-runtime 0.6.13196 → 0.6.13201

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b6b772ecaa9f6ce7788173f15073e96d619a88d575c72c36701e0f33b2f7796
-  data.tar.gz: e986c62848ac7bef03f533753b233d151167c285dc1011023dfff4378c74ae0c
+  metadata.gz: 79fd6653c60d5ef471285c20e256f0c648b7c4eecabdb6fd984a001e3a65777d
+  data.tar.gz: ad5746e9bb9b4ac3e308b14eebb2a087ca380172fa5d7155e364b6d225348d00
 SHA512:
-  metadata.gz: 15840ef1936591b0b06fc987a1d53952e2ff5f3c0f83e3f8ed39da9a9a510c838b6aa9f451919262e39923f7f7af071b76e1b2b1323316038f2f8f84bfdb7be4
-  data.tar.gz: a9dcc51625a817d74cdc6be20cd7a66d6288df0b3d0628a66296c786859901c1f159cf9b33062c0a16cf653de2728e80d944b1438acbea7076c0cab9804e1079
+  metadata.gz: b41d0550e429ed6b54de6a67639134015e1fdfb1e313a9138a031a5783542e0884d92a2493ad19fbeafb61fb2a8961ea1561f9340c47d2d1febcdccd076867db
+  data.tar.gz: ff0278c3333264eec7ad1468fa0459cde87037946137d0b649a5686c0ec3fb3163c2eb51e5237c32047590a3140d89d990aabb08faa9c7ba7750cc02bfa329bc

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

@@ -56,11 +56,6 @@ module T::Private::Methods
     nil
   end
 
-  # See tests for how to use this.  But you shouldn't be using this.
-  def self._declare_sig(mod, arg=nil, &blk)
-    _declare_sig_internal(mod, caller_locations(1, 1)&.first, arg, raw: true, &blk)
-  end
-
   private_class_method def self._declare_sig_internal(mod, loc, arg, raw: false, &blk)
     install_hooks(mod)
 
@@ -76,21 +71,6 @@ module T::Private::Methods
     DeclarationBlock.new(mod, loc, blk, arg == :final, raw)
   end
 
-  def self._with_declared_signature(mod, declblock, &blk)
-    # If declblock is provided, this code is equivalent to the check in
-    # _declare_sig_internal, above.
-    # If declblock is not provided and we have an active declaration, we are
-    # obviously doing something wrong.
-    if T::Private::DeclState.current.active_declaration
-      T::Private::DeclState.current.reset!
-      raise "You called sig twice without declaring a method in between"
-    end
-    if declblock
-      T::Private::DeclState.current.active_declaration = declblock
-    end
-    mod.module_exec(&blk)
-  end
-
   def self.start_proc
     DeclBuilder.new(PROC_TYPE, false)
   end
@@ -131,14 +111,14 @@ module T::Private::Methods
   #
   # we assume that source_method_names has already been filtered to only include method
   # names that were declared final at one point.
-  def self._check_final_ancestors(target, target_ancestors, source_method_names, source)
+  def self._check_final_ancestors(target, source_method_names, source)
     source_ancestors = nil
     if T::Private::IS_TYPECHECKING
       # Need to avoid a pinning error, but don't want to use runtime types in _methods.rb
       source_ancestors = T.let(nil, T.nilable(T::Array[T::Module[T.anything]]))
     end
     # use reverse_each to check farther-up ancestors first, for better error messages.
-    target_ancestors.reverse_each do |ancestor|
+    target.ancestors.reverse_each do |ancestor|
       final_methods = @modules_with_final.fetch(ancestor, nil)
       # In this case, either ancestor didn't have any final methods anywhere in its
       # ancestor chain, or ancestor did have final methods somewhere in its ancestor
@@ -200,6 +180,9 @@ module T::Private::Methods
   end
 
   def self.add_module_with_final_method(mod, method_name)
+    @was_ever_final_names[method_name] = true
+
+    # Side-effectfully initializes the value if it's not already there
     methods = @modules_with_final[mod]
     if methods.nil?
       methods = {}
@@ -209,12 +192,6 @@ module T::Private::Methods
     nil
   end
 
-  def self.note_module_deals_with_final(mod)
-    # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod]
-    @modules_with_final[mod.singleton_class]
-  end
-
   # Only public because it needs to get called below inside the replace_method blocks below.
   def self._on_method_added(hook_mod, mod, method_name)
     if T::Private::DeclState.current.skip_on_method_added
@@ -228,7 +205,7 @@ module T::Private::Methods
     end
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
     if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod)
-      _check_final_ancestors(mod, mod.ancestors, [method_name], nil)
+      _check_final_ancestors(mod, [method_name], nil)
       # We need to fetch the active declaration again, as _check_final_ancestors
       # may have reset it (see the comment in that method for details).
       current_declaration = T::Private::DeclState.current.active_declaration
@@ -286,10 +263,6 @@ module T::Private::Methods
 
     @sig_wrappers[key] = sig_block
     if current_declaration.final
-      @was_ever_final_names[method_name] = true
-      # use hook_mod, not mod, because for example, we want class C to be marked as having final if we def C.foo as
-      # final. change this to mod to see some final_method tests fail.
-      note_module_deals_with_final(hook_mod)
       add_module_with_final_method(mod, method_name)
     end
   end
@@ -518,14 +491,15 @@ module T::Private::Methods
 
   # the module target is adding the methods from the module source to itself. we need to check that for all instance
   # methods M on source, M is not defined on any of target's ancestors.
-  def self._hook_impl(target, singleton_class, source)
+  def self._hook_impl(target, source)
     # we do not need to call add_was_ever_final here, because we have already marked
     # any such methods when source was originally defined.
     if !@modules_with_final.include?(target)
       if !@modules_with_final.include?(source)
         return
       end
-      note_module_deals_with_final(target)
+      # Side-effectfully initialize the value if it's not already there
+      @modules_with_final[target]
       install_hooks(target)
       return
     end
@@ -538,8 +512,7 @@ module T::Private::Methods
       return
     end
 
-    target_ancestors = singleton_class ? target.singleton_class.ancestors : target.ancestors
-    _check_final_ancestors(target, target_ancestors, methods, source)
+    _check_final_ancestors(target, methods, source)
   end
 
   def self.set_final_checks_on_hooks(enable)
@@ -563,17 +536,18 @@ module T::Private::Methods
       old_included = Module.instance_method(:included)
       T::Private::ClassUtils.replace_method(old_included, Module, :included) do |arg|
         old_included.bind_call(self, arg)
-        ::T::Private::Methods._hook_impl(arg, false, self)
+        ::T::Private::Methods._hook_impl(arg, self)
       end
       old_extended = Module.instance_method(:extended)
       T::Private::ClassUtils.replace_method(old_extended, Module, :extended) do |arg|
         old_extended.bind_call(self, arg)
-        ::T::Private::Methods._hook_impl(arg, true, self)
+        ::T::Private::Methods._hook_impl(arg.singleton_class, self)
       end
       old_inherited = Class.instance_method(:inherited)
       T::Private::ClassUtils.replace_method(old_inherited, Class, :inherited) do |arg|
         old_inherited.bind_call(self, arg)
-        ::T::Private::Methods._hook_impl(arg, false, self)
+        ::T::Private::Methods._hook_impl(arg, self)
+        ::T::Private::Methods._hook_impl(arg.singleton_class, self.singleton_class)
       end
       @old_hooks = [old_included, old_extended, old_inherited]
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13196
+  version: 0.6.13201
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-07 00:00:00.000000000 Z
+date: 2026-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark