[Fix #11765] Fix an error for Style/MultilineMethodSignature

Fixes #11765.

This PR fixes an error for `Style/MultilineMethodSignature`
when line break after `def` keyword.

It seems preferable that the following cases can be detected by a new different cop:

```ruby
def
method_name arg; end
```

This is probably not a common line break, the new cop will be able to handle `class`, `module`,
class method definitions, and others as well.

And this `Style/MultilineMethodSignature` cop is disabled by default,
but I have a feeling that the new cop can be enabled by default.

changelog/fix_an_error_for_style_multiline_method_signature.md

@@ -0,0 +1 @@
+* [#11765](https://github.com/rubocop/rubocop/issues/11765): Fix an error for `Style/MultilineMethodSignature` when line break after `def` keyword. ([@koic][])

lib/rubocop/cop/style/multiline_method_signature.rb

@@ -28,14 +28,17 @@ def on_def(node)
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
+          return unless (begin_of_arguments = node.arguments.loc.begin)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node, begin_of_arguments)
+          end
         end
         alias on_defs on_def
 
         private
 
-        def autocorrect(corrector, node)
+        def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
           last_line_source_of_arguments = last_line_source_of_arguments(arguments)
@@ -47,7 +50,7 @@ def autocorrect(corrector, node)
           end
 
           corrector.remove(arguments_range(node))
-          corrector.insert_after(arguments.loc.begin, joined_arguments)
+          corrector.insert_after(begin_of_arguments, joined_arguments)
         end
 
         def last_line_source_of_arguments(arguments)

spec/rubocop/cop/style/multiline_method_signature_spec.rb

@@ -36,6 +36,23 @@ def foo(arg)
         RUBY
       end
 
+      it 'registers an offense and corrects when closing paren is on the following line' \
+         'and line break after `def` keyword' do
+        expect_offense(<<~RUBY)
+          def
+          ^^^ Avoid multi-line method signatures.
+          foo(bar
+              )
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          def
+          foo(bar)
+          end
+        RUBY
+      end
+
       context 'when method signature is on a single line' do
         it 'does not register an offense for parameterized method' do
           expect_no_offenses(<<~RUBY)
@@ -51,6 +68,13 @@ def foo
           RUBY
         end
       end
+
+      it 'does not register an offense when line break after `def` keyword' do
+        expect_no_offenses(<<~RUBY)
+          def
+          method_name arg; end
+        RUBY
+      end
     end
 
     context 'when defining an class method' do