Accept parentheses in argument calls with blocks

changelog/fix_accept_parentheses_in_argument_calls_with_blocks.md

@@ -0,0 +1 @@
+* [#12610](https://github.com/rubocop/rubocop/pull/12610): Accept parentheses in argument calls with blocks for `Style/MethodCallWithArgsParentheses` `omit_parentheses` style. ([@gsamokovarov][])

lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -127,23 +127,31 @@ def call_in_single_line_inheritance?(node)
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
               call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.forwarded_args_type? || n.block_type? ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) && node.block_node&.braces?
+            (node.call_type? || node.super_type?) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.block_type? && node.parent&.parent
+            return false unless parent
+
+            parent.call_type? || parent.super_type? || parent.yield_type?
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
-              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
+              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+              !assigned_before?(node.parent, node)
           end
 
           def call_in_match_pattern?(node)

spec/rubocop/cop/style/method_call_with_args_parentheses_spec.rb

@@ -785,7 +785,7 @@ def seatle_style arg: default(42)
       expect_no_offenses('foo(1) { 2 }')
     end
 
-    it 'accepts parens in array literal calls' do
+    it 'accepts parens in array literal calls with blocks' do
       expect_no_offenses(<<~RUBY)
         [
           foo.bar.quux(:args) do
@@ -1058,6 +1058,46 @@ def seatle_style arg: default(42)
           )
         RUBY
       end
+
+      it 'accepts parens in argument calls with blocks' do
+        expect_no_offenses(<<~RUBY)
+          foo(
+            bar.new(quux) do
+              pass
+            end
+          )
+        RUBY
+      end
+
+      it 'accepts parens in argument csend with blocks' do
+        expect_no_offenses(<<~RUBY)
+          foo(
+            bar&.new(quux) do
+              pass
+            end
+          )
+        RUBY
+      end
+
+      it 'accepts parens in super argument call with blocks' do
+        expect_no_offenses(<<~RUBY)
+          super(
+            bar.new(quux) do
+              pass
+            end
+          )
+        RUBY
+      end
+
+      it 'accepts parens in yield argument call with blocks' do
+        expect_no_offenses(<<~RUBY)
+          yield(
+            bar.new(quux) do
+              pass
+            end
+          )
+        RUBY
+      end
     end
 
     context 'allowing parens in camel-case methods' do