Fix a false negative for Style/OperatorMethodCall

This PR fixes a false negative for `Style/OperatorMethodCall`
when using `a.+ b.something`.

The following is the difference depending on whether there is the dot or not.

It is the same when the argument is not enclosed in parentheses:

```console
% ruby-parse -e "a.+ b.something"
(send
  (send nil :a) :+
  (send
    (send nil :b) :something))

% ruby-parse -e "a + b.something"
(send
  (send nil :a) :+
  (send
    (send nil :b) :something))
```

It is different when the argument is enclosed in parentheses.

```console
% ruby-parse -e "a.+(b).something"
(send
  (send
    (send nil :a) :+
    (send nil :b)) :something)

% ruby-parse -e "a +(b).something"
(send nil :a
  (send
    (send
      (begin
        (send nil :b)) :something) :+@))
```

So the former should be warned by this cop.

changelog/fix_a_false_negative_for_style_operator_method_call.md

@@ -0,0 +1 @@
+* [#11379](https://github.com/rubocop/rubocop/pull/11379): Fix a false negative for `Style/OperatorMethodCall` when using `a.+ b.something`. ([@koic][])

lib/rubocop/cop/style/operator_method_call.rb

@@ -28,7 +28,7 @@ def on_send(node)
           return if node.receiver.const_type?
 
           _lhs, _op, rhs = *node
-          return if rhs.nil? || rhs.children.first || rhs.forwarded_args_type?
+          return if rhs.nil? || parenthesized_argument?(rhs) || rhs.forwarded_args_type?
 
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
@@ -38,6 +38,10 @@ def on_send(node)
 
         private
 
+        def parenthesized_argument?(argument)
+          argument.children.first && argument.parent.parenthesized?
+        end
+
         def wrap_in_parentheses_if_chained(corrector, node)
           return unless node.parent&.call_type?
 

spec/rubocop/cop/style/operator_method_call_spec.rb

@@ -43,9 +43,20 @@
     end
   end
 
-  it 'does not register an offense when using `foo.+@bar.to_s`' do
+  it 'registers an offense when using `foo.+ @bar.to_s`' do
+    expect_offense(<<~RUBY)
+      foo.+ @bar.to_s
+         ^ Redundant dot detected.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      foo + @bar.to_s
+    RUBY
+  end
+
+  it 'does not register an offense when using `foo.+(@bar).to_s`' do
     expect_no_offenses(<<~RUBY)
-      foo.+ bar.to_s
+      foo.+(@bar).to_s
     RUBY
   end