sorbet-runtime 0.6.13412 → 0.6.13414

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12f5cde61fc274c67b1e6230f7662c4d97079fb76dd37248b77601652b301123
-  data.tar.gz: a557477677d13ba37a1ec5e2ca923d844fadaf5414761d6fffcf49a5afebd1eb
+  metadata.gz: c785f4639764f63f21035a28e89190a76a91b8c03bed613c2a1173df0affb145
+  data.tar.gz: 17d9de2b1f8cff74c7d4793b64bcc5f50f37f6647ba1bdd3dc5566c087cc4a4b
 SHA512:
-  metadata.gz: ede94d922ffbdc539855d627bf67c4947148179f7b1e426f150806a91e7d2b78eece10f8a22851a18f0cf5bd9c9c8df8b685452fdb38af09a65324ff020a26c5
-  data.tar.gz: 6df95518c869b5c12a0f7ac873be2b38359f249a03dbc68020d20199f104d55055df9dc9c1bb51e83165dd3bf241f504362b46fdddd6b100632c2bea0e4a9a96
+  metadata.gz: 7dabc7ec609291736c71f2fe2864b71f46cbc602266138cb9f9726175eb5a521d1e0ba4cf552e27ff138b4e1023ac1e47586f5340cbbf3c943f9eeeecf08bdad
+  data.tar.gz: 1150cd3d617f5c87aeb20d258320e52481857b4f00d14d1fdebd0b9cc2c88f0d01e48615be25a09cc92576ed3ce25c26960d00e773e5f96054a399a4b8f74308

data/lib/types/private/decl_state.rb

@@ -13,6 +13,7 @@ class T::Private::DeclState
   attr_accessor :active_declaration
   attr_accessor :skip_on_method_added
   attr_accessor :previous_declaration
+  attr_accessor :last_method_key
 
   def reset!
     self.active_declaration = nil

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

@@ -42,13 +42,16 @@ module T::Private::Methods
   end
   # rubocop:enable Naming/ClassAndModuleCamelCase
 
-  # blk_or_decl:
+  # sig_state:
   # - It's a `Proc` if we haven't forced the thunk yet.
   # - It's a `Declaration` if we have, but we haven't finished building the sig
   #   (This can matter for circular load-time behavior, where a method is
   #   called while its Signature is being built)
-  # - It's `nil` if we've finished building the sig
-  DeclarationBlock = Struct.new(:mod, :method_name, :loc, :blk_or_decl, :final, :abstract, :override, :overridable)
+  # - It's a `Signature` if we've finished building the sig. This allows
+  #   the first-call wrapper to find its own signature even if it was
+  #   evaluated externally (e.g., by run_all_sig_blocks) and
+  #   @signatures_by_method[key] was overwritten by a redefinition.
+  DeclarationBlock = Struct.new(:mod, :method_name, :loc, :sig_state, :final, :abstract, :override, :overridable)
 
   def self.declare_sig(mod, loc, arg, &blk)
     if T::Private::DeclState.current.active_declaration
@@ -76,7 +79,7 @@ module T::Private::Methods
       raise DeclBuilder::BuilderError.new("You must declare a `sig` before using `#{dsl_name}` on the method `#{method_name}`")
     end
 
-    if !previous_declaration.blk_or_decl.is_a?(Proc)
+    if !previous_declaration.sig_state.is_a?(Proc)
       raise DeclBuilder::BuilderError.new("Cannot call `#{dsl_name} #{method_name.inspect}`, because the sig block has already run")
     end
 
@@ -320,6 +323,43 @@ module T::Private::Methods
     end
 
     if current_declaration.nil?
+      key = method_owner_and_name_to_key(mod, method_name)
+
+      # `last_method_key` guards against multiple calls to `_on_method_added`,
+      # from having multiple copies of the method in the ancestor chain (this
+      # can happen commonly if `Module` is monkey patched, because various
+      # files in sorbet-runtime itself run `extend T::Sig` before a monkey
+      # patch has a chance to fire).
+      #
+      # This is a performance optimization, to guarantee that methods with
+      # `.checked(:never)` sigs are unwrapped on first call rather than
+      # permanently trapped behind the first-call wrapper (which allocates via
+      # `|*args, &blk|` on every call). Without this guard, the duplicate
+      # `_on_method_added` deletes the key from `@sig_wrappers`, so the wrapper
+      # can never find its sig block and never unwraps.
+      if decl_state.last_method_key == key
+        return
+      end
+
+      # Drop any existing sig, because the `sig_block` closes over the
+      # `original_method` at the time that the sig wrapper was registered, and
+      # forcing the sig would thus redefine the the redefined method back to
+      # the original method.
+      old_sig = @sig_wrappers.delete(key)
+
+      # Ruby only reports method redefinitions if `$VERBOSE` is truthy. Let's
+      # do the same for sigs.
+      if old_sig && $VERBOSE
+        # We can probably get away with not printing any location information
+        # (like the Ruby VM would for method redefinition warnings) because the
+        # Ruby VM itself will have printed the location information in its
+        # method redefinition warning (and it does that faster, using functions
+        # that constult the CFP directly).
+        Warning.warn(
+          "sorbet-runtime: warning: Dropping unevaluated signature for #{mod}##{method_name} because it was redefined\n"
+        )
+      end
+
       return
     end
 
@@ -348,7 +388,7 @@ module T::Private::Methods
 
     original_method = mod.instance_method(method_name)
     sig_block = lambda do
-      T::Private::Methods.run_sig(method_name, original_method, current_declaration)
+      T::Private::Methods.run_sig(method_name, original_method, current_declaration, unwrap: true)
     end
 
     # Always replace the original method with this wrapper,
@@ -356,23 +396,56 @@ module T::Private::Methods
     # 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)
+    built_sig = nil
+    if T::Private::IS_TYPECHECKING
+      built_sig = T.let(nil, T.nilable(Signature))
+    end
     T::Private::ClassUtils.replace_method(original_method, mod, method_name) do |*args, &blk|
-      method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
+      callee = Kernel.__callee__ || raise("Unknown __callee__ for method without a signature")
+      method_sig = built_sig
       if !method_sig
-        callee = __callee__ || raise("Unknown __callee__ for method without a signature")
-        method_sig = T::Private::Methods.signature_for_method(original_method)
+        # Check if this wrapper's sig_block is still the active one for this key
+        #
+        # If not, the method was redefined and this wrapper is being called via
+        # a captured method object from reflection (e.g., `instance_method` or
+        # `method` from before the redefinition).
+        #
+        # We can only use maybe_run_sig_block_for_key if there was no
+        # redefinition, because it would otherwise call unwrap_method,
+        # overwriting the redefinition.
+        method_sig =
+          if T::Private::Methods._sig_block_is_current?(key, sig_block)
+            T::Private::Methods.maybe_run_sig_block_for_key(key)
+          elsif !(method_sig = current_declaration.sig_state).is_a?(Signature)
+            # This is essentially a permanent slow path: since the method was
+            # redefined before the sig block had a chance to run, we can't unwrap
+            # the method, as that would overwrite the redefinition, effectively
+            # putting the method back to its original definition. (Note that
+            # `run_sig` is what we call in the `sig_block`, but this one just
+            # doesn't unwrap.)
+            T::Private::Methods.run_sig(method_name, original_method, current_declaration, unwrap: false)
+          else
+            # The declaration was already consumed (e.g., module_function copies
+            # the first-call wrapper to the singleton class, sharing the same
+            # DeclarationBlock; if the instance method's sig is evaluated first,
+            # sig_state is a Signature when the singleton copy runs).
+            method_sig
+          end
         if !method_sig
-          raise "`sig` not present for method `#{callee}` on #{self.inspect} but you're trying to run it anyways. " \
-            "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
-            "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method."
+          method_sig = T::Private::Methods.signature_for_method(original_method)
+          if !method_sig
+            raise "`sig` not present for method `#{callee}` on #{self.inspect} but you're trying to run it anyways. " \
+              "This should only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but that clearly isn't what you are doing. " \
+              "Maybe look to see if an exception was thrown in your `sig` lambda or somehow else your `sig` wasn't actually applied to the method."
+          end
         end
+        built_sig = method_sig
+      end
 
-        method_sig = T::Private::Methods._unwrap_alias(
-          method_sig,
-          self,
-          original_method,
-          callee,
-        )
+      # If this wrapper is being called via an alias, unwrap the alias so
+      # subsequent calls bypass the wrapper entirely.
+      if callee != method_name
+        T::Private::Methods._unwrap_alias(method_sig, self, original_method, callee)
       end
 
       # Should be the same logic as CallValidation.wrap_method_if_needed but we
@@ -397,6 +470,8 @@ module T::Private::Methods
     if current_declaration.final
       add_module_with_final_method(mod, method_name)
     end
+
+    key
   end
 
   # Only public so that it can be accessed in the closure for _on_method_added
@@ -432,7 +507,7 @@ module T::Private::Methods
 
   # Executes the `sig` block, and converts the resulting Declaration
   # to a Signature.
-  def self.run_sig(method_name, original_method, declaration_block)
+  def self.run_sig(method_name, original_method, declaration_block, unwrap:)
     current_declaration =
       begin
         run_builder(declaration_block)
@@ -451,21 +526,29 @@ module T::Private::Methods
         Signature.new_untyped(method: original_method)
       end
 
-    unwrap_method(signature.method.owner, signature, original_method)
+    if unwrap
+      unwrap_method(signature.method.owner, signature, original_method)
+    end
 
-    # Drop this declaration. Only drop it after we've actually wrapped the
-    # method and recorded the signature, because that might raise an exception,
-    # leaving the declaration in a weird state if the program rescues that
-    # exception and continues.
-    declaration_block.blk_or_decl = nil
+    # Store the finished signature (dropping the Declaration in the process).
+    # Only do this after we've actually wrapped the method and recorded the
+    # signature, because that might raise an exception, leaving the
+    # declaration in a weird state if the program rescues that exception and
+    # continues.
+    #
+    # Storing the signature here allows the first-call wrapper to find its
+    # own signature even if it was evaluated externally (e.g., by
+    # run_all_sig_blocks) and @signatures_by_method[key] was later overwritten
+    # by a redefinition.
+    declaration_block.sig_state = signature
 
     signature
   end
 
   def self.run_builder(declaration_block)
-    blk_or_decl = declaration_block.blk_or_decl
-    return blk_or_decl if blk_or_decl.is_a?(Declaration)
-    if blk_or_decl.nil?
+    sig_state = declaration_block.sig_state
+    return sig_state if sig_state.is_a?(Declaration)
+    if !sig_state.is_a?(Proc)
       raise "DeclarationBlock for #{declaration_block.mod} at #{declaration_block.loc} should have already been unwrapped"
     end
 
@@ -475,9 +558,9 @@ module T::Private::Methods
       declaration_block.override,
       declaration_block.overridable
     )
-    decl = builder.instance_exec(&blk_or_decl).finalize!.decl
+    decl = builder.instance_exec(&sig_state).finalize!.decl
     # Record that we've already run `blk` once and constructed a `Declaration`
-    declaration_block.blk_or_decl = decl
+    declaration_block.sig_state = decl
     decl
   end
 
@@ -536,6 +619,11 @@ module T::Private::Methods
     has_sig_block_for_key(method_to_key(method))
   end
 
+  # Only public because it needs to get called inside the first-call wrapper closure.
+  def self._sig_block_is_current?(key, sig_block)
+    @sig_wrappers[key].equal?(sig_block)
+  end
+
   private_class_method def self.has_sig_block_for_key(key)
     @sig_wrappers.key?(key)
   end
@@ -685,15 +773,19 @@ module T::Private::Methods
 
   module MethodHooks
     def method_added(name)
-      ::T::Private::Methods._on_method_added(T.unsafe(self), T.unsafe(self), name)
+      key = ::T::Private::Methods._on_method_added(T.unsafe(self), T.unsafe(self), name)
+      T::Private::DeclState.current.last_method_key = key if key
       super(name)
+      T::Private::DeclState.current.last_method_key = nil if key
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
-      ::T::Private::Methods._on_method_added(T.unsafe(self), singleton_class, name)
+      key = ::T::Private::Methods._on_method_added(T.unsafe(self), singleton_class, name)
+      T::Private::DeclState.current.last_method_key = key if key
       super(name)
+      T::Private::DeclState.current.last_method_key = nil if key
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-runtime
 version: !ruby/object:Gem::Version
-  version: 0.6.13412
+  version: 0.6.13414
 platform: ruby
 authors:
 - Stripe