sorbet-runtime 0.5.6437 → 0.5.6453

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8ecca92c44541d24bb04c5b793a62777aa9a72f927e417710dd170f6c5493f3
-  data.tar.gz: 0116352dd8ee2baa548ffc479e0e7ef53f76242e0354e61f186d96ae781fa93b
+  metadata.gz: aa133acfa00111d8518fe6f2b7306e5f805644c3c89f7d98d865bfcb1544fc99
+  data.tar.gz: 8eb1604d0688b7b253762de525ba26d28db324ccf2320e8cac15acfb03b38cad
 SHA512:
-  metadata.gz: 1a5d7124fba4d4342ed2bd1760f3e42b0c1a564b127ea13ba3688b967764886c3a922ba68598856c2f4f9442accdbc2b582bb6a22c896d18efaa922fe54506a5
-  data.tar.gz: 6020c7561fb7c9df1a4b8de96a898adb477cf16f76e82e343d4436d40f8009e5e5dfed7e47250fa1a1ff3ade8fae61c59056e0dd98457491562f2004141af615
+  metadata.gz: 597c26f0960c654dd4cc8838428e1ab089773837f0a2514d36bd2f87340d212a205e75b70249667b1629db66c08979c0e1b7edc6ada2e3f676fd5a660c8e1967
+  data.tar.gz: fc5ae47c2fedfbe67831f66231a7d69c06f5ad63ba1ba7917e3228b6e392edd2d0fd24a0ae60ff1029f2524f432d72c60e8eef395300f6919e6353c87cc3aeb7

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

@@ -26,6 +26,8 @@ module T::Private::Methods
   # in installed_hooks.
   @old_hooks = nil
 
+  @declaring_final_method = false
+
   ARG_NOT_PROVIDED = Object.new
   PROC_TYPE = Object.new
 
@@ -180,6 +182,17 @@ module T::Private::Methods
     @modules_with_final[mod.singleton_class]
   end
 
+  # See tests for how to use this.
+  def self._with_declaring_final_method_INTERNAL(&blk)
+    begin
+      prev_value = @declaring_final_method
+      @declaring_final_method = true
+      yield
+    ensure
+      @declaring_final_method = prev_value
+    end
+  end
+
   # Only public because it needs to get called below inside the replace_method blocks below.
   def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
     if T::Private::DeclState.current.skip_on_method_added
@@ -189,7 +202,9 @@ module T::Private::Methods
     current_declaration = T::Private::DeclState.current.active_declaration
     mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
 
-    if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.final)
+    directly_declaring_final_method = @declaring_final_method
+    method_is_final = directly_declaring_final_method || current_declaration&.final
+    if T::Private::Final.final_module?(mod) && !method_is_final
       raise "#{mod} was declared as final but its method `#{method_name}` was not declared as final"
     end
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
@@ -212,46 +227,49 @@ module T::Private::Methods
       )
     end
 
-    original_method = mod.instance_method(method_name)
-    sig_block = lambda do
-      T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
-    end
-
-    # Always replace the original method with this wrapper,
-    # which is called only on the *first* invocation.
-    # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
-    # (or unwrap back to the original method).
-    key = method_owner_and_name_to_key(mod, method_name)
-    T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
-      method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
-      method_sig ||= T::Private::Methods._handle_missing_method_signature(
-        self,
-        original_method,
-        __callee__,
-      )
+    unless directly_declaring_final_method
+      original_method = mod.instance_method(method_name)
+      sig_block = lambda do
+        T::Private::Methods.run_sig(hook_mod, method_name, original_method, current_declaration)
+      end
 
-      # Should be the same logic as CallValidation.wrap_method_if_needed but we
-      # don't want that extra layer of indirection in the callstack
-      if method_sig.mode == T::Private::Methods::Modes.abstract
-        # We're in an interface method, keep going up the chain
-        if defined?(super)
-          super(*args, &blk)
+      # Always replace the original method with this wrapper,
+      # which is called only on the *first* invocation.
+      # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
+      # (or unwrap back to the original method).
+      key = method_owner_and_name_to_key(mod, method_name)
+      T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+        method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
+        method_sig ||= T::Private::Methods._handle_missing_method_signature(
+          self,
+          original_method,
+          __callee__,
+        )
+
+        # Should be the same logic as CallValidation.wrap_method_if_needed but we
+        # don't want that extra layer of indirection in the callstack
+        if method_sig.mode == T::Private::Methods::Modes.abstract
+          # We're in an interface method, keep going up the chain
+          if defined?(super)
+            super(*args, &blk)
+          else
+            raise NotImplementedError.new("The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation.")
+          end
+        # Note, this logic is duplicated (intentionally, for micro-perf) at `CallValidation.wrap_method_if_needed`,
+        # make sure to keep changes in sync.
+        elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+          CallValidation.validate_call(self, original_method, method_sig, args, blk)
+        elsif T::Configuration::AT_LEAST_RUBY_2_7
+          original_method.bind_call(self, *args, &blk)
         else
-          raise NotImplementedError.new("The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation.")
+          original_method.bind(self).call(*args, &blk)
         end
-      # Note, this logic is duplicated (intentionally, for micro-perf) at `CallValidation.wrap_method_if_needed`,
-      # make sure to keep changes in sync.
-      elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-        CallValidation.validate_call(self, original_method, method_sig, args, blk)
-      elsif T::Configuration::AT_LEAST_RUBY_2_7
-        original_method.bind_call(self, *args, &blk)
-      else
-        original_method.bind(self).call(*args, &blk)
       end
+
+      @sig_wrappers[key] = sig_block
     end
 
-    @sig_wrappers[key] = sig_block
-    if current_declaration.final
+    if method_is_final
       @was_ever_final_names.add(method_name)
       # 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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.5.6437
+  version: 0.5.6453
 platform: ruby
 authors:
 - Stripe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-10 00:00:00.000000000 Z
+date: 2021-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest