[Fix #12141] Fix false positive for Style/ArgumentsForwarding

If additional kwargs are supplied then forward-all (`...`) cannot be
used.

changelog/fix_fix_false_positive_for_style_arguments_forwarding.md

@@ -0,0 +1 @@
+* [#12141](https://github.com/rubocop/rubocop/issues/12141): Fix false positive for `Style/ArgumentsForwarding` when method def includes additional kwargs. ([@owst][])

lib/rubocop/cop/style/arguments_forwarding.rb

@@ -291,7 +291,7 @@ def can_forward_all?
             return false if any_arg_referenced?
             return false if ruby_32_missing_rest_or_kwest?
             return false unless offensive_block_forwarding?
-            return false if forward_additional_kwargs?
+            return false if additional_kwargs_or_forwarded_kwargs?
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
@@ -339,6 +339,14 @@ def no_post_splat_args?
             [nil, :hash, :block_pass].include?(arg_after_splat&.type)
           end
 
+          def additional_kwargs_or_forwarded_kwargs?
+            additional_kwargs? || forward_additional_kwargs?
+          end
+
+          def additional_kwargs?
+            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+          end
+
           def forward_additional_kwargs?
             return false unless forwarded_kwrest_arg
 

spec/rubocop/cop/style/arguments_forwarding_spec.rb

@@ -283,6 +283,14 @@ def foo((bar, baz), **kwargs)
       RUBY
     end
 
+    it 'does not register an offense with an additional kwarg' do
+      expect_no_offenses(<<~RUBY)
+        def foo(first:, **kwargs, &block)
+          forwarded(**kwargs, &block)
+        end
+      RUBY
+    end
+
     context 'AllowOnlyRestArgument: true' do
       let(:cop_config) { { 'AllowOnlyRestArgument' => true } }
 
@@ -444,6 +452,38 @@ def foo(m, *args, &block)
       RUBY
     end
 
+    it 'does not register an offense with an additional required kwarg that is not forwarded' do
+      expect_no_offenses(<<~RUBY)
+        def foo(first:, **kwargs, &block)
+          forwarded(**kwargs, &block)
+        end
+      RUBY
+    end
+
+    it 'does not register an offense with an additional required kwarg that is forwarded' do
+      expect_no_offenses(<<~RUBY)
+        def foo(first:, **kwargs, &block)
+          forwarded(first: first, **kwargs, &block)
+        end
+      RUBY
+    end
+
+    it 'does not register an offense with an additional optional kwarg that is not forwarded' do
+      expect_no_offenses(<<~RUBY)
+        def foo(first: nil, **kwargs, &block)
+          forwarded(**kwargs, &block)
+        end
+      RUBY
+    end
+
+    it 'does not register an offense with an additional optional kwarg that is forwarded' do
+      expect_no_offenses(<<~RUBY)
+        def foo(first: nil, **kwargs, &block)
+          forwarded(first: first, **kwargs, &block)
+        end
+      RUBY
+    end
+
     it 'does not register an offense if args/kwargs are forwarded with a positional parameter last' do
       expect_no_offenses(<<~RUBY)
         def foo(m, *args, **kwargs, &block)
@@ -1098,6 +1138,88 @@ def foo(*, **, &block)
       RUBY
     end
 
+    it 'registers an offense with an additional required kwarg that is not forwarded' do
+      expect_offense(<<~RUBY)
+        def foo(first:, **kwargs, &block)
+                        ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+          forwarded(**kwargs, &block)
+                    ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        def foo(first:, **, &block)
+          forwarded(**, &block)
+        end
+      RUBY
+    end
+
+    it 'registers an offense with an additional required kwarg that is forwarded' do
+      expect_offense(<<~RUBY)
+        def foo(first:, **kwargs, &block)
+                        ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+          forwarded(first: first, **kwargs, &block)
+                                  ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        def foo(first:, **, &block)
+          forwarded(first: first, **, &block)
+        end
+      RUBY
+    end
+
+    it 'registers an offense with an additional optional kwarg that is not forwarded' do
+      expect_offense(<<~RUBY)
+        def foo(first: nil, **kwargs, &block)
+                            ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+          forwarded(first:, **kwargs, &block)
+                            ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        def foo(first: nil, **, &block)
+          forwarded(first:, **, &block)
+        end
+      RUBY
+    end
+
+    it 'registers an offense with an additional optional kwarg that is forwarded' do
+      expect_offense(<<~RUBY)
+        def foo(first: nil, **kwargs, &block)
+                            ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+          forwarded(first: first, **kwargs, &block)
+                                  ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        def foo(first: nil, **, &block)
+          forwarded(first: first, **, &block)
+        end
+      RUBY
+    end
+
+    it 'registers an offense with an arg and additional optional kwarg that is forwarded' do
+      expect_offense(<<~RUBY)
+        def foo(*args, first: nil, **kwargs, &block)
+                ^^^^^ Use anonymous positional arguments forwarding (`*`).
+                                   ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+          forwarded(*args, first: first, **kwargs, &block)
+                    ^^^^^ Use anonymous positional arguments forwarding (`*`).
+                                         ^^^^^^^^ Use anonymous keyword arguments forwarding (`**`).
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        def foo(*, first: nil, **, &block)
+          forwarded(*, first: first, **, &block)
+        end
+      RUBY
+    end
+
     it 'registers an offense when using restarg and block arg' do
       expect_offense(<<~RUBY)
         def foo(*args, &block)