Add support for endless methods to `Style/MethodCallWithArgsParenthes…

…es`.

.rubocop_todo.yml

@@ -23,7 +23,7 @@ Metrics/MethodLength:
 # Offense count: 8
 # Configuration parameters: CountComments.
 Metrics/ModuleLength:
-  Max: 132
+  Max: 135
 
 # Offense count: 10
 RSpec/AnyInstance:

changelog/fix_endless_emthod_method_call_with_args_parentheses.md

@@ -0,0 +1 @@
+* [#9279](https://github.com/rubocop-hq/rubocop/pull/9279): Add support for endless methods to `Style/MethodCallWithArgsParentheses`. ([@dvandersluis][])

config/default.yml

@@ -3548,7 +3548,7 @@ Style/MethodCallWithArgsParentheses:
   StyleGuide: '#method-invocation-parens'
   Enabled: false
   VersionAdded: '0.47'
-  VersionChanged: '0.61'
+  VersionChanged: <<next>>
   IgnoreMacros: true
   IgnoredMethods: []
   IgnoredPatterns: []

lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -40,6 +40,9 @@ module Style
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
+      # NOTE: Parens are required around a method with arguments when inside an
+      # endless method definition (>= Ruby 3.0).
+      #
       # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad

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

@@ -14,25 +14,35 @@ module OmitParentheses
 
           def omit_parentheses(node)
             return unless node.parenthesized?
+            return if inside_endless_method_def?(node)
             return if node.implicit_call?
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              if parentheses_at_the_end_of_multiline_call?(node)
-                corrector.replace(args_begin(node), ' \\')
-              else
-                corrector.replace(args_begin(node), ' ')
-              end
-              corrector.remove(node.loc.end)
+              auto_correct(corrector, node)
+            end
+          end
+
+          def auto_correct(corrector, node)
+            if parentheses_at_the_end_of_multiline_call?(node)
+              corrector.replace(args_begin(node), ' \\')
+            else
+              corrector.replace(args_begin(node), ' ')
             end
+            corrector.remove(node.loc.end)
           end
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
+          def inside_endless_method_def?(node)
+            # parens are required around arguments inside an endless method
+            node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

spec/rubocop/cop/style/method_call_with_args_parentheses_spec.rb

@@ -1,7 +1,48 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::Style::MethodCallWithArgsParentheses, :config do
+  shared_examples 'endless methods' do |omit: false|
+    context 'endless methods', :ruby30 do
+      context 'with arguments' do
+        it 'requires method calls to have parens' do
+          expect_no_offenses(<<~RUBY)
+            def x() = foo("bar")
+          RUBY
+        end
+      end
+
+      context 'without arguments' do
+        if omit
+          it 'registers an offense when there are parens' do
+            expect_offense(<<~RUBY)
+              def x() = foo()
+                           ^^ Omit parentheses for method calls with arguments.
+            RUBY
+
+            expect_correction(<<~RUBY)
+              def x() = foo#{trailing_whitespace}
+            RUBY
+          end
+        else
+          it 'does not register an offense when there are parens' do
+            expect_no_offenses(<<~RUBY)
+              def x() = foo()
+            RUBY
+          end
+        end
+
+        it 'does not register an offense when there are no parens' do
+          expect_no_offenses(<<~RUBY)
+            def x() = foo
+          RUBY
+        end
+      end
+    end
+  end
+
   context 'when EnforcedStyle is require_parentheses (default)' do
+    it_behaves_like 'endless methods'
+
     it 'accepts no parens in method call without args' do
       expect_no_offenses('top.test')
     end
@@ -318,6 +359,8 @@ module Foo
       { 'EnforcedStyle' => 'omit_parentheses' }
     end
 
+    it_behaves_like 'endless methods', omit: true
+
     it 'register an offense for parens in method call without args' do
       trailing_whitespace = ' '
 
@@ -796,6 +839,8 @@ def seatle_style arg: default(42)
       }
     end
 
+    it_behaves_like 'endless methods'
+
     context 'in a class body' do
       it 'finds offense' do
         expect_offense(<<~RUBY)