sorbet-runtime 0.6.13398 → 0.6.13403

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d0ef663103465c62f33bd4cbbb1d16a0ca815793189c06169f967d34a7f1801
-  data.tar.gz: b1521a442b3a1796232b01845cfa30ba3283d20e0ddc5eb8b2b81867dac951b7
+  metadata.gz: d4390dc1e5918b665c08b6d70d128d2fb972b45d3a48e38b52a1b118908688a9
+  data.tar.gz: a557477677d13ba37a1ec5e2ca923d844fadaf5414761d6fffcf49a5afebd1eb
 SHA512:
-  metadata.gz: c780f6b07da80a693165bc0867686b324c664e88c4473b09e4aed8ad05a82f496d356e02a9af5e5cbd07746d605990d71399bedd16fa0fab5d03e6a69504f4e5
-  data.tar.gz: 0cefee08a1abe28c7bb65b42d72e4d7cfb6eb8bf53b77c2541272904e609c6dbf7ac476f3b342b33a418f6d978de5622d0dc4a463c523df77a9572bd18c8d7cb
+  metadata.gz: 67774164e7c21616303eb62964072f907fb49e11b4dfdb0aff1b17f2a6cef94ab2f09211e6048b2086cbe944dabe968cecc353467f04f7fb60244eb5d82a9174
+  data.tar.gz: 6df95518c869b5c12a0f7ac873be2b38359f249a03dbc68020d20199f104d55055df9dc9c1bb51e83165dd3bf241f504362b46fdddd6b100632c2bea0e4a9a96

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

@@ -42,16 +42,13 @@ module T::Private::Methods
   end
   # rubocop:enable Naming/ClassAndModuleCamelCase
 
-  # sig_state:
+  # blk_or_decl:
   # - 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 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)
+  # - It's `nil` if we've finished building the sig
+  DeclarationBlock = Struct.new(:mod, :method_name, :loc, :blk_or_decl, :final, :abstract, :override, :overridable)
 
   def self.declare_sig(mod, loc, arg, &blk)
     if T::Private::DeclState.current.active_declaration
@@ -79,7 +76,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.sig_state.is_a?(Proc)
+    if !previous_declaration.blk_or_decl.is_a?(Proc)
       raise DeclBuilder::BuilderError.new("Cannot call `#{dsl_name} #{method_name.inspect}`, because the sig block has already run")
     end
 
@@ -323,26 +320,6 @@ module T::Private::Methods
     end
 
     if current_declaration.nil?
-      key = method_owner_and_name_to_key(mod, method_name)
-      # 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
 
@@ -371,7 +348,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, unwrap: true)
+      T::Private::Methods.run_sig(method_name, original_method, current_declaration)
     end
 
     # Always replace the original method with this wrapper,
@@ -379,56 +356,23 @@ 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|
-      callee = Kernel.__callee__ || raise("Unknown __callee__ for method without a signature")
-      method_sig = built_sig
+      method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
       if !method_sig
-        # 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
+        callee = __callee__ || raise("Unknown __callee__ for method without a signature")
+        method_sig = T::Private::Methods.signature_for_method(original_method)
         if !method_sig
-          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
+          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
-        built_sig = method_sig
-      end
 
-      # 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)
+        method_sig = 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
@@ -488,7 +432,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, unwrap:)
+  def self.run_sig(method_name, original_method, declaration_block)
     current_declaration =
       begin
         run_builder(declaration_block)
@@ -507,29 +451,21 @@ module T::Private::Methods
         Signature.new_untyped(method: original_method)
       end
 
-    if unwrap
-      unwrap_method(signature.method.owner, signature, original_method)
-    end
+    unwrap_method(signature.method.owner, signature, original_method)
 
-    # 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
+    # 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
 
     signature
   end
 
   def self.run_builder(declaration_block)
-    sig_state = declaration_block.sig_state
-    return sig_state if sig_state.is_a?(Declaration)
-    if !sig_state.is_a?(Proc)
+    blk_or_decl = declaration_block.blk_or_decl
+    return blk_or_decl if blk_or_decl.is_a?(Declaration)
+    if blk_or_decl.nil?
       raise "DeclarationBlock for #{declaration_block.mod} at #{declaration_block.loc} should have already been unwrapped"
     end
 
@@ -539,9 +475,9 @@ module T::Private::Methods
       declaration_block.override,
       declaration_block.overridable
     )
-    decl = builder.instance_exec(&sig_state).finalize!.decl
+    decl = builder.instance_exec(&blk_or_decl).finalize!.decl
     # Record that we've already run `blk` once and constructed a `Declaration`
-    declaration_block.sig_state = decl
+    declaration_block.blk_or_decl = decl
     decl
   end
 
@@ -600,11 +536,6 @@ 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

metadata

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