increase coverage

Author: chris-olszewski

temporalio/lib/temporalio/worker/activity_executor/fiber.rb

@@ -23,7 +23,7 @@ def initialize_activity(defn)
         end
 
         # @see ActivityExecutor.initialize_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           ::Fiber.schedule(&)
         end
 

temporalio/lib/temporalio/worker/activity_executor/thread_pool.rb

@@ -20,7 +20,7 @@ def initialize(thread_pool = Worker::ThreadPool.default) # rubocop:disable Lint/
         end
 
         # @see ActivityExecutor.execute_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           @thread_pool.execute(&)
         end
 

temporalio/test/support/sig_applicator.rb

@@ -142,7 +142,7 @@ def register_summary_hook!
     def raise_instrumentation_errors!(errors)
       return if errors.empty?
 
-      summary = +"SigApplicator: #{errors.size} methods could not be instrumented:\n"
+      summary = "SigApplicator: #{errors.size} methods could not be instrumented:\n"
       errors.each { |error| summary << "  #{error}\n" }
       raise summary.chomp
     end
@@ -169,7 +169,7 @@ def apply_scope(node, errors)
         case child
         when RBI::Method
           target = child.is_singleton ? klass.singleton_class : klass
-          result = apply_method_sig(target, class_name, child, errors)
+          result = apply_method_sig(target, class_name, child, errors, sig_eval_scope: klass)
           if result == :skipped
             skipped += 1
           elsif result
@@ -179,7 +179,14 @@ def apply_scope(node, errors)
           child.nodes.each do |scn|
             next unless scn.is_a?(RBI::Method)
 
-            result = apply_method_sig(klass.singleton_class, class_name, scn, errors, class_method: true)
+            result = apply_method_sig(
+              klass.singleton_class,
+              class_name,
+              scn,
+              errors,
+              class_method: true,
+              sig_eval_scope: klass
+            )
             if result == :skipped
               skipped += 1
             elsif result
@@ -191,11 +198,12 @@ def apply_scope(node, errors)
       [applied, skipped]
     end
 
-    def apply_method_sig(target, class_name, method_node, errors, class_method: false)
+    def apply_method_sig(target, class_name, method_node, errors, class_method: false, sig_eval_scope: target)
       return false if method_node.sigs.empty?
 
       method_name = method_node.name.to_sym
-      separator = class_method || method_node.is_singleton ? '.' : '#'
+      singleton_method = class_method || method_node.is_singleton
+      separator = singleton_method ? '.' : '#'
       full_name = "#{class_name}#{separator}#{method_name}"
 
       return :skipped if SKIP_METHODS.include?(full_name)
@@ -214,10 +222,11 @@ def apply_method_sig(target, class_name, method_node, errors, class_method: fals
       method_node.sigs.each do |sig|
         # RBI::Sig#string serializes back to valid T::Sig DSL source
         sig_source = sig.string
-        # Anonymous block params (def foo(&)) need `"&":` instead of `block:`
-        sig_source = rewrite_block_param(sig_source) if has_anon_block
+        # Anonymous block params (def foo(&)) need `"&":` instead of the RBI
+        # block parameter name.
+        sig_source = rewrite_block_param(sig_source, method_node, sig) if has_anon_block
         begin
-          target.class_eval(sig_source)
+          apply_sig_source(sig_eval_scope, target, sig_source, singleton_method)
           target.send(:define_method, method_name, original)
 
           # Force eager sig validation so mismatches are caught now rather than
@@ -240,10 +249,28 @@ def anonymous_block?(method)
       block_param && (block_param[1].nil? || block_param[1] == :&)
     end
 
-    # Rewrites `block: <type>` to `"&": <type>` in a sig source string
-    # so sorbet-runtime matches the anonymous block parameter.
-    def rewrite_block_param(sig_source)
-      sig_source.sub(/\bblock:\s/, '"&": ')
+    def apply_sig_source(sig_eval_scope, target, sig_source, singleton_method)
+      if singleton_method
+        sig_eval_scope.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          class << self
+            #{sig_source} # #{sig_source}
+          end
+        RUBY
+      else
+        target.class_eval(sig_source)
+      end
+    end
+
+    # Rewrites the RBI block parameter name to `"&": <type>` so
+    # sorbet-runtime matches the anonymous block parameter.
+    def rewrite_block_param(sig_source, method_node, sig)
+      block_param_name =
+        method_node.params.find { |param| param.is_a?(RBI::BlockParam) }&.name ||
+        sig.params.find { |param| param.type&.include?('T.proc') }&.name
+
+      return sig_source unless block_param_name
+
+      sig_source.sub(/\b#{Regexp.escape(block_param_name)}:\s/, '"&": ')
     end
 
     # Determines whether a method should be skipped for sig application based

temporalio/test/support/sig_applicator_test.rb

@@ -53,14 +53,18 @@ def foo(&blk); end # rubocop:disable Naming/BlockForwarding
     # --- Anonymous block sig rewriting ---
 
     def test_rewrite_block_param
-      input = 'sig { params(name: String, block: T.proc.void).void }'
+      input = 'sig { params(name: String, blk: T.proc.void).void }'
       expected = 'sig { params(name: String, "&": T.proc.void).void }'
-      assert_equal expected, rewrite_block_param(input)
+      method_node = parse_method(
+        'class X; sig { params(name: String, blk: T.proc.void).void }; def foo(name, &blk); end; end'
+      )
+      assert_equal expected, rewrite_block_param(input, method_node, method_node.sigs.first)
     end
 
     def test_rewrite_block_param_no_block
       input = 'sig { params(name: String).void }'
-      assert_equal input, rewrite_block_param(input)
+      method_node = parse_method('class X; sig { params(name: String).void }; def foo(name); end; end')
+      assert_equal input, rewrite_block_param(input, method_node, method_node.sigs.first)
     end
 
     # --- Setter / unnamed param skips ---
@@ -150,10 +154,61 @@ def self.foo(value); end
       assert_includes error.message, 'Support::SigApplicatorApplyAllTest.foo:'
     ensure
       parser.send(:define_method, :parse_file, original_parse_file)
-      Support.send(:remove_const, :SigApplicatorApplyAllTest) if Support.const_defined?(:SigApplicatorApplyAllTest, false)
+      if Support.const_defined?(:SigApplicatorApplyAllTest, false)
+        Support.send(:remove_const, :SigApplicatorApplyAllTest)
+      end
       Object.send(:remove_const, :ZZZSigApplicatorTest) if Object.const_defined?(:ZZZSigApplicatorTest)
     end
 
+    def test_apply_method_sig_supports_anonymous_block_with_named_rbi_block
+      klass = Class.new do
+        extend T::Sig
+
+        def foo(&); end
+      end
+      method_node = parse_method(
+        'class X; sig { params(blk: T.proc.void).void }; def foo(&blk); end; end'
+      )
+      errors = []
+
+      assert apply_method_sig(klass, 'X', method_node, errors, sig_eval_scope: klass)
+      assert_empty errors
+    end
+
+    def test_apply_method_sig_resolves_singleton_sig_constants_in_class_namespace
+      klass = Class.new do
+        extend T::Sig
+
+        class << self
+          extend T::Sig
+        end
+
+        def self.foo(value); end
+      end
+      klass.const_set(:Inner, Data.define(:value))
+      Support.const_set(:SigApplicatorSingletonScopeTest, klass)
+      method_node = parse_method(<<~RBI)
+        class Support::SigApplicatorSingletonScopeTest
+          sig { params(value: Inner).void }
+          def self.foo(value); end
+        end
+      RBI
+      errors = []
+
+      assert apply_method_sig(
+        klass.singleton_class,
+        'Support::SigApplicatorSingletonScopeTest',
+        method_node,
+        errors,
+        sig_eval_scope: klass
+      )
+      assert_empty errors
+    ensure
+      if Support.const_defined?(:SigApplicatorSingletonScopeTest, false)
+        Support.send(:remove_const, :SigApplicatorSingletonScopeTest)
+      end
+    end
+
     private
 
     def parse_method(source)
@@ -166,8 +221,19 @@ def skip_method?(original, method_node, method_name)
       SigApplicator.send(:skip_method?, original, method_node, method_name)
     end
 
-    def rewrite_block_param(sig_source)
-      SigApplicator.send(:rewrite_block_param, sig_source)
+    def rewrite_block_param(sig_source, method_node, sig)
+      SigApplicator.send(:rewrite_block_param, sig_source, method_node, sig)
+    end
+
+    def apply_method_sig(target, class_name, method_node, errors, sig_eval_scope:)
+      SigApplicator.send(
+        :apply_method_sig,
+        target,
+        class_name,
+        method_node,
+        errors,
+        sig_eval_scope:
+      )
     end
   end
 end

temporalio/test/test.rb

@@ -17,11 +17,14 @@
 
 if ENV['TEMPORAL_SORBET_RUNTIME_CHECK']
   # Load modules that are lazy-loaded so their types can be instrumented
+  require 'temporalio/common_enums'
   require 'temporalio/contrib/open_telemetry'
   require 'temporalio/converters/payload_codec'
   require 'temporalio/env_config'
   require 'temporalio/simple_plugin'
+  require 'temporalio/worker/interceptor'
   require 'temporalio/worker/workflow_replayer'
+  require 'temporalio/workflow'
 
   require 'support/sig_applicator'
   SigApplicator.apply_all!